idx int64 | project string | commit_id string | project_url string | commit_url string | commit_message string | target int64 | func string | func_hash float64 | file_name string | file_hash float64 | cwe list | cve string | cve_desc string | nvd_url string |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
21,284 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | pause_tube_peek()
{
int i;
tube t, nt = NULL;
for (i = 0; i < tubes.used; i++) {
t = tubes.items[i];
if (t->pause) {
if (!nt || t->deadline_at < nt->deadline_at) nt = t;
}
}
return nt;
}
| 33,200,842,939,115,026,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,285 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | peek_job(uint64_t id)
{
return job_find(id);
}
| 171,133,535,682,586,800,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,286 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | process_queue()
{
job j;
usec now = now_usec();
dprintf("processing queue\n");
while ((j = next_eligible_job(now))) {
dprintf("got eligible job %llu in %s\n", j->id, j->tube->name);
j = pq_take(&j->tube->ready);
ready_ct--;
if (j->pri < URGENT_THRESHOLD) {
gl... | 248,026,850,844,276,840,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,287 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | prot_init()
{
started_at = now_usec();
memset(op_ct, 0, sizeof(op_ct));
ms_init(&tubes, NULL, NULL);
TUBE_ASSIGN(default_tube, tube_find_or_make("default"));
if (!default_tube) twarnx("Out of memory during startup!");
}
| 9,909,421,503,501,343,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,288 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | prot_remove_tube(tube t)
{
ms_remove(&tubes, t);
}
| 236,636,049,122,158,300,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,289 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | prot_replay_binlog(job binlog_jobs)
{
job j, nj;
usec delay;
int r;
for (j = binlog_jobs->next ; j != binlog_jobs ; j = nj) {
nj = j->next;
job_remove(j);
binlog_reserve_space_update(j); /* reserve space for a delete */
delay = 0;
switch (j->state) {
case... | 330,932,773,901,492,600,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,290 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | read_delay(usec *delay, const char *buf, char **end)
{
int r;
unsigned int delay_sec;
r = read_pri(&delay_sec, buf, end);
if (r) return r;
*delay = ((usec) delay_sec) * 1000000;
return 0;
}
| 226,561,076,919,437,770,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,291 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | read_pri(unsigned int *pri, const char *buf, char **end)
{
char *tend;
unsigned int tpri;
errno = 0;
while (buf[0] == ' ') buf++;
if (!isdigit(buf[0])) return -1;
tpri = strtoul(buf, &tend, 10);
if (tend == buf) return -1;
if (errno && errno != ERANGE) return -1;
if (!end && tend[0]... | 22,933,284,156,189,927,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,292 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | read_tube_name(char **tubename, char *buf, char **end)
{
size_t len;
while (buf[0] == ' ') buf++;
len = strspn(buf, NAME_CHARS);
if (len == 0) return -1;
if (tubename) *tubename = buf;
if (end) *end = buf + len;
return 0;
}
| 278,723,206,128,565,400,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,293 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | remove_buried_job(job j)
{
if (!j || j->state != JOB_STATE_BURIED) return NULL;
j = job_remove(j);
if (j) {
global_stat.buried_ct--;
j->tube->stat.buried_ct--;
}
return j;
}
| 107,704,623,250,027,140,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,294 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | remove_ready_job(job j)
{
if (!j || j->state != JOB_STATE_READY) return NULL;
j = pq_remove(&j->tube->ready, j);
if (j) {
ready_ct--;
if (j->pri < URGENT_THRESHOLD) {
global_stat.urgent_ct--;
j->tube->stat.urgent_ct--;
}
}
return j;
}
| 269,836,554,139,942,220,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,295 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | remove_reserved_job(conn c, job j)
{
return remove_this_reserved_job(c, find_reserved_job_in_conn(c, j));
}
| 54,484,260,620,101,510,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,296 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | remove_this_reserved_job(conn c, job j)
{
j = job_remove(j);
if (j) {
global_stat.reserved_ct--;
j->tube->stat.reserved_ct--;
j->reserver = NULL;
}
c->soonest_job = NULL;
if (!job_list_any_p(&c->reserved_jobs)) conn_remove(c);
return j;
}
| 317,675,650,067,439,500,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,297 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | remove_waiting_conn(conn c)
{
tube t;
size_t i;
if (!conn_waiting(c)) return NULL;
c->type &= ~CONN_TYPE_WAITING;
global_stat.waiting_ct--;
for (i = 0; i < c->watch.used; i++) {
t = c->watch.items[i];
t->stat.waiting_ct--;
ms_remove(&t->waiting, c);
}
return c;
... | 174,406,284,361,290,050,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,298 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | reply(conn c, const char *line, int len, int state)
{
int r;
if (!c) return;
r = conn_update_evq(c, EV_WRITE | EV_PERSIST);
if (r == -1) return twarnx("conn_update_evq() failed"), conn_close(c);
c->reply = line;
c->reply_len = len;
c->reply_sent = 0;
c->state = state;
dprintf("sen... | 265,188,787,044,546,230,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,299 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | reply_job(conn c, job j, const char *word)
{
/* tell this connection which job to send */
c->out_job = j;
c->out_job_sent = 0;
return reply_line(c, STATE_SENDJOB, "%s %llu %u\r\n",
word, j->id, j->body_size - 2);
}
| 620,955,235,927,316,500,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,300 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | reply_line(conn c, int state, const char *fmt, ...)
{
int r;
va_list ap;
va_start(ap, fmt);
r = vsnprintf(c->reply_buf, LINE_BUF_SIZE, fmt, ap);
va_end(ap);
/* Make sure the buffer was big enough. If not, we have a bug. */
if (r >= LINE_BUF_SIZE) return reply_serr(c, MSG_INTERNAL_ERROR);
... | 33,949,472,867,768,570,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,301 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | reset_conn(conn c)
{
int r;
r = conn_update_evq(c, EV_READ | EV_PERSIST);
if (r == -1) return twarnx("update events failed"), conn_close(c);
/* was this a peek or stats command? */
if (c->out_job && c->out_job->state == JOB_STATE_COPY) job_free(c->out_job);
c->out_job = NULL;
c->reply_sen... | 197,199,173,492,544,140,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,302 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | scan_line_end(const char *s, int size)
{
char *match;
match = memchr(s, '\r', size - 1);
if (!match) return 0;
/* this is safe because we only scan size - 1 chars above */
if (match[1] == '\n') return match - s + 2;
return 0;
}
| 152,598,898,317,462,250,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,303 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | set_main_delay_timeout()
{
job j = delay_q_peek();
tube t = pause_tube_peek();
usec deadline_at = t ? t->deadline_at : 0;
if (j && (!deadline_at || j->deadline_at < deadline_at)) deadline_at = j->deadline_at;
dprintf("deadline_at=%" PRIu64 "\n", deadline_at);
set_main_timeout(deadline_at);
}
| 291,294,155,775,450,740,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,304 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | touch_job(conn c, job j)
{
j = find_reserved_job_in_conn(c, j);
if (j) {
j->deadline_at = now_usec() + j->ttr;
c->soonest_job = NULL;
}
return j;
}
| 323,640,305,952,674,700,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,305 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | uptime()
{
return (now_usec() - started_at) / 1000000;
}
| 138,104,817,697,766,230,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,306 | beanstalkd | 2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | http://github.com/kr/beanstalkd | http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d | Discard job body bytes if the job is too big.
Previously, a malicious user could craft a job payload and inject
beanstalk commands without the client application knowing. (An
extra-careful client library could check the size of the job body before
sending the put command, but most libraries do not do this, nor should
... | 0 | which_cmd(conn c)
{
#define TEST_CMD(s,c,o) if (strncmp((s), (c), CONSTSTRLEN(c)) == 0) return (o);
TEST_CMD(c->cmd, CMD_PUT, OP_PUT);
TEST_CMD(c->cmd, CMD_PEEKJOB, OP_PEEKJOB);
TEST_CMD(c->cmd, CMD_PEEK_READY, OP_PEEK_READY);
TEST_CMD(c->cmd, CMD_PEEK_DELAYED, OP_PEEK_DELAYED);
TEST_CMD(c->cmd, CMD... | 203,397,531,727,742,060,000,000,000,000,000,000,000 | None | null | [] | CVE-2010-2060 | The put command functionality in beanstalkd 1.4.5 and earlier allows remote attackers to execute arbitrary Beanstalk commands via the body in a job that is too big, which is not properly handled by the dispatch_cmd function in prot.c. | https://nvd.nist.gov/vuln/detail/CVE-2010-2060 |
21,307 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void add_bin_header(conn *c, uint16_t err, uint8_t hdr_len, uint16_t key_len, uint32_t body_len) {
protocol_binary_response_header* header;
assert(c);
c->msgcurr = 0;
c->msgused = 0;
c->iovused = 0;
if (add_msghdr(c) != 0) {
/* XXX: out_string is inappropriate here */
o... | 1,957,516,436,356,522,500,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,308 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static int add_iov(conn *c, const void *buf, int len) {
struct msghdr *m;
int leftover;
bool limit_to_mtu;
assert(c != NULL);
do {
m = &c->msglist[c->msgused - 1];
/*
* Limit UDP packets, and the first payloads of TCP replies, to
* UDP_MAX_PAYLOAD_SIZE bytes.
... | 197,910,007,984,816,740,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,309 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void append_ascii_stats(const char *key, const uint16_t klen,
const char *val, const uint32_t vlen,
conn *c) {
char *pos = c->stats.buffer + c->stats.offset;
uint32_t nbytes = 0;
int remaining = c->stats.size - c->stats.offset;
int roo... | 68,782,798,004,888,740,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,310 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void append_bin_stats(const char *key, const uint16_t klen,
const char *val, const uint32_t vlen,
conn *c) {
char *buf = c->stats.buffer + c->stats.offset;
uint32_t bodylen = klen + vlen;
protocol_binary_response_header header = {
.res... | 222,114,921,256,589,020,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,311 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void append_stats(const char *key, const uint16_t klen,
const char *val, const uint32_t vlen,
const void *cookie)
{
/* value without a key is invalid */
if (klen == 0 && vlen > 0) {
return ;
}
conn *c = (conn*)cookie;
if (c->protocol == binary_pro... | 17,218,782,674,279,622,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,312 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static bool authenticated(conn *c) {
assert(settings.sasl);
bool rv = false;
switch (c->cmd) {
case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS: /* FALLTHROUGH */
case PROTOCOL_BINARY_CMD_SASL_AUTH: /* FALLTHROUGH */
case PROTOCOL_BINARY_CMD_SASL_STEP: /* FALLTHROUGH */
case PROTOCOL_BI... | 207,399,859,524,310,060,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,313 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void bin_list_sasl_mechs(conn *c) {
if (!settings.sasl) {
write_bin_error(c, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND,
c->binary_header.request.bodylen
- c->binary_header.request.keylen);
return;
}
init_sasl_conn(c);
const char *res... | 79,406,670,799,167,750,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,314 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void bin_read_key(conn *c, enum bin_substates next_substate, int extra) {
assert(c);
c->substate = next_substate;
c->rlbytes = c->keylen + extra;
/* Ok... do we have room for the extras and the key in the input buffer? */
ptrdiff_t offset = c->rcurr + sizeof(protocol_binary_request_header) -... | 301,188,873,120,510,200,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,315 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static char* binary_get_key(conn *c) {
return c->rcurr - (c->binary_header.request.keylen);
}
| 247,946,123,018,871,700,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,316 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static int build_udp_headers(conn *c) {
int i;
unsigned char *hdr;
assert(c != NULL);
if (c->msgused > c->hdrsize) {
void *new_hdrbuf;
if (c->hdrbuf)
new_hdrbuf = realloc(c->hdrbuf, c->msgused * 2 * UDP_HEADER_SIZE);
else
new_hdrbuf = malloc(c->msgused *... | 169,109,840,901,868,580,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,317 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void clock_handler(const int fd, const short which, void *arg) {
struct timeval t = {.tv_sec = 1, .tv_usec = 0};
static bool initialized = false;
if (initialized) {
/* only delete the event if it's actually there. */
evtimer_del(&clockevent);
} else {
initialized = true;
... | 142,737,517,002,828,320,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,318 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void complete_incr_bin(conn *c) {
item *it;
char *key;
size_t nkey;
protocol_binary_response_incr* rsp = (protocol_binary_response_incr*)c->wbuf;
protocol_binary_request_incr* req = binary_get_request(c);
assert(c != NULL);
assert(c->wsize >= sizeof(*rsp));
/* fix byteorder in ... | 138,296,371,634,436,250,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,319 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void complete_nread(conn *c) {
assert(c != NULL);
assert(c->protocol == ascii_prot
|| c->protocol == binary_prot);
if (c->protocol == ascii_prot) {
complete_nread_ascii(c);
} else if (c->protocol == binary_prot) {
complete_nread_binary(c);
}
}
| 245,617,246,551,896,400,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,320 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void complete_nread_ascii(conn *c) {
assert(c != NULL);
item *it = c->item;
int comm = c->cmd;
enum store_item_type ret;
pthread_mutex_lock(&c->thread->stats.mutex);
c->thread->stats.slab_stats[it->slabs_clsid].set_cmds++;
pthread_mutex_unlock(&c->thread->stats.mutex);
if (strn... | 35,785,997,944,166,750,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,321 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void complete_update_bin(conn *c) {
protocol_binary_response_status eno = PROTOCOL_BINARY_RESPONSE_EINVAL;
enum store_item_type ret = NOT_STORED;
assert(c != NULL);
item *it = c->item;
pthread_mutex_lock(&c->thread->stats.mutex);
c->thread->stats.slab_stats[it->slabs_clsid].set_cmds++;
... | 35,044,867,148,606,665,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,322 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | bool conn_add_to_freelist(conn *c) {
bool ret = true;
pthread_mutex_lock(&conn_lock);
if (freecurr < freetotal) {
freeconns[freecurr++] = c;
ret = false;
} else {
/* try to enlarge free connections array */
size_t newsize = freetotal * 2;
conn **new_freeconns = re... | 273,369,164,600,030,320,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,323 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void conn_cleanup(conn *c) {
assert(c != NULL);
if (c->item) {
item_remove(c->item);
c->item = 0;
}
if (c->ileft != 0) {
for (; c->ileft > 0; c->ileft--,c->icurr++) {
item_remove(*(c->icurr));
}
}
if (c->suffixleft != 0) {
for (; c->s... | 40,012,103,025,461,167,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,324 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void conn_close(conn *c) {
assert(c != NULL);
/* delete the event, the socket and the conn */
event_del(&c->event);
if (settings.verbose > 1)
fprintf(stderr, "<%d connection closed.\n", c->sfd);
MEMCACHED_CONN_RELEASE(c->sfd);
close(c->sfd);
accept_new_conns(true);
conn... | 315,771,417,707,507,960,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,325 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | void conn_free(conn *c) {
if (c) {
MEMCACHED_CONN_DESTROY(c);
if (c->hdrbuf)
free(c->hdrbuf);
if (c->msglist)
free(c->msglist);
if (c->rbuf)
free(c->rbuf);
if (c->wbuf)
free(c->wbuf);
if (c->ilist)
free(c->il... | 100,654,121,416,079,980,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,326 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | conn *conn_from_freelist() {
conn *c;
pthread_mutex_lock(&conn_lock);
if (freecurr > 0) {
c = freeconns[--freecurr];
} else {
c = NULL;
}
pthread_mutex_unlock(&conn_lock);
return c;
}
| 107,031,803,747,073,300,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,327 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void conn_init(void) {
freetotal = 200;
freecurr = 0;
if ((freeconns = calloc(freetotal, sizeof(conn *))) == NULL) {
fprintf(stderr, "Failed to allocate connection structures\n");
}
return;
}
| 26,590,857,824,853,063,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,328 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | conn *conn_new(const int sfd, enum conn_states init_state,
const int event_flags,
const int read_buffer_size, enum network_transport transport,
struct event_base *base) {
conn *c = conn_from_freelist();
if (NULL == c) {
if (!(c = (conn *)calloc(1, sizeof(... | 53,987,323,377,491,740,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,329 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void conn_set_state(conn *c, enum conn_states state) {
assert(c != NULL);
assert(state >= conn_listening && state < conn_max_state);
if (state != c->state) {
if (settings.verbose > 2) {
fprintf(stderr, "%d: going from %s to %s\n",
c->sfd, state_text(c->state),... | 22,583,962,061,396,330,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,330 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void conn_shrink(conn *c) {
assert(c != NULL);
if (IS_UDP(c->transport))
return;
if (c->rsize > READ_BUFFER_HIGHWAT && c->rbytes < DATA_BUFFER_SIZE) {
char *newbuf;
if (c->rcurr != c->rbuf)
memmove(c->rbuf, c->rcurr, (size_t)c->rbytes);
newbuf = (char *... | 117,098,708,758,965,450,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,331 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void dispatch_bin_command(conn *c) {
int protocol_error = 0;
int extlen = c->binary_header.request.extlen;
int keylen = c->binary_header.request.keylen;
uint32_t bodylen = c->binary_header.request.bodylen;
if (settings.sasl && !authenticated(c)) {
write_bin_error(c, PROTOCOL_BINARY_... | 48,988,892,559,187,480,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,332 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | void do_accept_new_conns(const bool do_accept) {
conn *next;
for (next = listen_conn; next; next = next->next) {
if (do_accept) {
update_event(next, EV_READ | EV_PERSIST);
if (listen(next->sfd, settings.backlog) != 0) {
perror("listen");
}
}
... | 117,037,122,821,171,770,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,333 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | enum delta_result_type do_add_delta(conn *c, item *it, const bool incr,
const int64_t delta, char *buf) {
char *ptr;
uint64_t value;
int res;
ptr = ITEM_data(it);
if (!safe_strtoull(ptr, &value)) {
return NON_NUMERIC;
}
if (incr) {
value... | 139,436,887,450,744,700,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,334 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void drive_machine(conn *c) {
bool stop = false;
int sfd, flags = 1;
socklen_t addrlen;
struct sockaddr_storage addr;
int nreqs = settings.reqs_per_event;
int res;
assert(c != NULL);
while (!stop) {
switch(c->state) {
case conn_listening:
addrlen = s... | 201,440,702,806,308,000,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,335 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static int enable_large_pages(void) {
#if defined(HAVE_GETPAGESIZES) && defined(HAVE_MEMCNTL)
int ret = -1;
size_t sizes[32];
int avail = getpagesizes(sizes, 32);
if (avail != -1) {
size_t max = sizes[0];
struct memcntl_mha arg = {0};
int ii;
for (ii = 1; ii < avail; ++i... | 322,518,965,279,919,150,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,336 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static int ensure_iov_space(conn *c) {
assert(c != NULL);
if (c->iovused >= c->iovsize) {
int i, iovnum;
struct iovec *new_iov = (struct iovec *)realloc(c->iov,
(c->iovsize * 2) * sizeof(struct iovec));
if (! new_iov)
return -1;
c->iov... | 54,168,231,523,290,110,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,337 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static bool grow_stats_buf(conn *c, size_t needed) {
size_t nsize = c->stats.size;
size_t available = nsize - c->stats.offset;
bool rv = true;
/* Special case: No buffer -- need to allocate fresh */
if (c->stats.buffer == NULL) {
nsize = 1024;
available = c->stats.size = c->stats.of... | 153,857,816,410,346,820,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,338 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void init_sasl_conn(conn *c) {
assert(c);
/* should something else be returned? */
if (!settings.sasl)
return;
if (!c->sasl_conn) {
int result=sasl_server_new("memcached",
NULL, NULL, NULL, NULL,
NULL, 0, &c->s... | 11,622,481,969,631,062,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,339 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | int main (int argc, char **argv) {
int c;
bool lock_memory = false;
bool do_daemonize = false;
bool preallocate = false;
int maxcore = 0;
char *username = NULL;
char *pid_file = NULL;
struct passwd *pw;
struct rlimit rlim;
char unit = '\0';
int size_max = 0;
/* listening ... | 31,332,000,920,403,490,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,340 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void maximize_sndbuf(const int sfd) {
socklen_t intsize = sizeof(int);
int last_good = 0;
int min, max, avg;
int old_size;
/* Start with the default size. */
if (getsockopt(sfd, SOL_SOCKET, SO_SNDBUF, &old_size, &intsize) != 0) {
if (settings.verbose > 0)
perror("gets... | 258,788,946,780,933,030,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,341 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static int new_socket(struct addrinfo *ai) {
int sfd;
int flags;
if ((sfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) == -1) {
return -1;
}
if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 ||
fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
perror("setting O_NONBLOCK")... | 39,546,820,919,679,040,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,342 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static int new_socket_unix(void) {
int sfd;
int flags;
if ((sfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
perror("socket()");
return -1;
}
if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 ||
fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
perror("setting O_NONBLOCK");
... | 264,233,338,128,244,000,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,343 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void out_string(conn *c, const char *str) {
size_t len;
assert(c != NULL);
if (c->noreply) {
if (settings.verbose > 1)
fprintf(stderr, ">%d NOREPLY %s\n", c->sfd, str);
c->noreply = false;
conn_set_state(c, conn_new_cmd);
return;
}
if (settings.v... | 49,955,428,623,630,370,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,344 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_arithmetic_command(conn *c, token_t *tokens, const size_t ntokens, const bool incr) {
char temp[INCR_MAX_STORAGE_LEN];
item *it;
uint64_t delta;
char *key;
size_t nkey;
assert(c != NULL);
set_noreply_maybe(c, tokens, ntokens);
if (tokens[KEY_TOKEN].length > KEY_MAX... | 6,646,705,418,438,164,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,345 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_bin_append_prepend(conn *c) {
char *key;
int nkey;
int vlen;
item *it;
assert(c != NULL);
key = binary_get_key(c);
nkey = c->binary_header.request.keylen;
vlen = c->binary_header.request.bodylen - nkey;
if (settings.verbose > 1) {
fprintf(stderr, "Value... | 335,291,309,931,397,600,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,346 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_bin_delete(conn *c) {
item *it;
protocol_binary_request_delete* req = binary_get_request(c);
char* key = binary_get_key(c);
size_t nkey = c->binary_header.request.keylen;
assert(c != NULL);
if (settings.verbose > 1) {
fprintf(stderr, "Deleting %s\n", key);
}
... | 258,309,212,649,310,000,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,347 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_bin_flush(conn *c) {
time_t exptime = 0;
protocol_binary_request_flush* req = binary_get_request(c);
if (c->binary_header.request.extlen == sizeof(req->message.body)) {
exptime = ntohl(req->message.body.expiration);
}
set_current_time();
if (exptime > 0) {
... | 77,268,900,021,162,550,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,348 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_bin_get(conn *c) {
item *it;
protocol_binary_response_get* rsp = (protocol_binary_response_get*)c->wbuf;
char* key = binary_get_key(c);
size_t nkey = c->binary_header.request.keylen;
if (settings.verbose > 1) {
int ii;
fprintf(stderr, "<%d GET ", c->sfd);
... | 233,314,836,586,462,700,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,349 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_bin_sasl_auth(conn *c) {
if (!settings.sasl) {
write_bin_error(c, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND,
c->binary_header.request.bodylen
- c->binary_header.request.keylen);
return;
}
assert(c->binary_header.request.extl... | 146,098,144,194,263,190,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,350 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_bin_stat(conn *c) {
char *subcommand = binary_get_key(c);
size_t nkey = c->binary_header.request.keylen;
if (settings.verbose > 1) {
int ii;
fprintf(stderr, "<%d STATS ", c->sfd);
for (ii = 0; ii < nkey; ++ii) {
fprintf(stderr, "%c", subcommand[ii]);
... | 283,669,415,479,330,570,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,351 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_bin_update(conn *c) {
char *key;
int nkey;
int vlen;
item *it;
protocol_binary_request_set* req = binary_get_request(c);
assert(c != NULL);
key = binary_get_key(c);
nkey = c->binary_header.request.keylen;
/* fix byteorder in the request */
req->message.body... | 308,290,001,087,261,570,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,352 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_command(conn *c, char *command) {
token_t tokens[MAX_TOKENS];
size_t ntokens;
int comm;
assert(c != NULL);
MEMCACHED_PROCESS_COMMAND_START(c->sfd, c->rcurr, c->rbytes);
if (settings.verbose > 1)
fprintf(stderr, "<%d %s\n", c->sfd, command);
/*
* for comm... | 97,904,135,009,223,040,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,353 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens, bool return_cas) {
char *key;
size_t nkey;
int i = 0;
item *it;
token_t *key_token = &tokens[KEY_TOKEN];
char *suffix;
assert(c != NULL);
do {
while(key_token->length != 0) {
key = key_... | 33,996,494,908,001,510,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,354 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_stat(conn *c, token_t *tokens, const size_t ntokens) {
const char *subcommand = tokens[SUBCOMMAND_TOKEN].value;
assert(c != NULL);
if (ntokens < 2) {
out_string(c, "CLIENT_ERROR bad command line");
return;
}
if (ntokens == 2) {
server_stats(&append_stats... | 99,887,702,109,728,280,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,355 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | inline static void process_stats_detail(conn *c, const char *command) {
assert(c != NULL);
if (strcmp(command, "on") == 0) {
settings.detail_enabled = 1;
out_string(c, "OK");
}
else if (strcmp(command, "off") == 0) {
settings.detail_enabled = 0;
out_string(c, "OK");
... | 142,425,832,200,369,400,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,356 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_update_command(conn *c, token_t *tokens, const size_t ntokens, int comm, bool handle_cas) {
char *key;
size_t nkey;
unsigned int flags;
int32_t exptime_int = 0;
time_t exptime;
int vlen;
uint64_t req_cas_id=0;
item *it;
assert(c != NULL);
set_noreply_maybe(c... | 209,436,706,315,642,830,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,357 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void process_verbosity_command(conn *c, token_t *tokens, const size_t ntokens) {
unsigned int level;
assert(c != NULL);
set_noreply_maybe(c, tokens, ntokens);
level = strtoul(tokens[1].value, NULL, 10);
settings.verbose = level > MAX_VERBOSITY_LEVEL ? MAX_VERBOSITY_LEVEL : level;
out_s... | 337,329,187,152,153,900,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,358 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static const char *prot_text(enum protocol prot) {
char *rv = "unknown";
switch(prot) {
case ascii_prot:
rv = "ascii";
break;
case binary_prot:
rv = "binary";
break;
case negotiating_prot:
rv = "auto-negotiate";
brea... | 178,709,015,597,686,600,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,359 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static rel_time_t realtime(const time_t exptime) {
/* no. of seconds in 30 days - largest possible delta exptime */
if (exptime == 0) return 0; /* 0 means never expire */
if (exptime > REALTIME_MAXDELTA) {
/* if item expiration is at/before the server started, give it an
expiration time... | 15,428,521,501,482,645,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,360 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void remove_pidfile(const char *pid_file) {
if (pid_file == NULL)
return;
if (unlink(pid_file) != 0) {
fprintf(stderr, "Could not remove the pid file %s.\n", pid_file);
}
}
| 106,706,340,180,786,240,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,361 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void reset_cmd_handler(conn *c) {
c->cmd = -1;
c->substate = bin_no_state;
if(c->item != NULL) {
item_remove(c->item);
c->item = NULL;
}
conn_shrink(c);
if (c->rbytes > 0) {
conn_set_state(c, conn_parse_cmd);
} else {
conn_set_state(c, conn_waiting);
... | 153,516,002,156,310,020,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,362 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void save_pid(const pid_t pid, const char *pid_file) {
FILE *fp;
if (pid_file == NULL)
return;
if ((fp = fopen(pid_file, "w")) == NULL) {
fprintf(stderr, "Could not open the pid file %s for writing\n", pid_file);
return;
}
fprintf(fp,"%ld\n", (long)pid);
if (fclo... | 59,407,725,320,952,280,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,363 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static int server_socket(int port, enum network_transport transport,
FILE *portnumber_file) {
int sfd;
struct linger ling = {0, 0};
struct addrinfo *ai;
struct addrinfo *next;
struct addrinfo hints = { .ai_flags = AI_PASSIVE,
.ai_family = AF_UNS... | 130,653,759,300,167,520,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,364 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static int server_socket_unix(const char *path, int access_mask) {
int sfd;
struct linger ling = {0, 0};
struct sockaddr_un addr;
struct stat tstat;
int flags =1;
int old_umask;
if (!path) {
return 1;
}
if ((sfd = new_socket_unix()) == -1) {
return 1;
}
/*
... | 97,330,279,347,037,150,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,365 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void set_current_time(void) {
struct timeval timer;
gettimeofday(&timer, NULL);
current_time = (rel_time_t) (timer.tv_sec - process_started);
}
| 14,470,242,836,228,934,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,366 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static inline bool set_noreply_maybe(conn *c, token_t *tokens, size_t ntokens)
{
int noreply_index = ntokens - 2;
/*
NOTE: this function is not the first place where we are going to
send the reply. We could send it instead from process_command()
if the request line has wrong number of tokens... | 123,467,284,092,010,540,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,367 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void settings_init(void) {
settings.use_cas = true;
settings.access = 0700;
settings.port = 11211;
settings.udpport = 11211;
/* By default this string should be NULL for getaddrinfo() */
settings.inter = NULL;
settings.maxbytes = 64 * 1024 * 1024; /* default is 64MB */
settings.ma... | 107,240,386,490,725,720,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,368 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void sig_handler(const int sig) {
printf("SIGINT handled.\n");
exit(EXIT_SUCCESS);
}
| 130,151,538,306,878,200,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,369 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static int sigignore(int sig) {
struct sigaction sa = { .sa_handler = SIG_IGN, .sa_flags = 0 };
if (sigemptyset(&sa.sa_mask) == -1 || sigaction(sig, &sa, 0) == -1) {
return -1;
}
return 0;
}
| 234,747,174,778,809,220,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,370 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static const char *state_text(enum conn_states state) {
const char* const statenames[] = { "conn_listening",
"conn_new_cmd",
"conn_waiting",
"conn_read",
"conn_... | 274,668,545,883,826,320,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,371 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void stats_init(void) {
stats.curr_items = stats.total_items = stats.curr_conns = stats.total_conns = stats.conn_structs = 0;
stats.get_cmds = stats.set_cmds = stats.get_hits = stats.get_misses = stats.evictions = 0;
stats.curr_bytes = stats.listen_disabled_num = 0;
stats.accepting_conns = true; ... | 55,860,029,801,779,610,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,372 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void stats_reset(void) {
STATS_LOCK();
stats.total_items = stats.total_conns = 0;
stats.evictions = 0;
stats.listen_disabled_num = 0;
stats_prefix_clear();
STATS_UNLOCK();
threadlocal_stats_reset();
item_stats_reset();
}
| 8,250,241,799,339,007,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,373 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static size_t tokenize_command(char *command, token_t *tokens, const size_t max_tokens) {
char *s, *e;
size_t ntokens = 0;
assert(command != NULL && tokens != NULL && max_tokens > 1);
for (s = e = command; ntokens < max_tokens - 1; ++e) {
if (*e == ' ') {
if (s != e) {
... | 36,446,488,964,771,770,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,374 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static enum transmit_result transmit(conn *c) {
assert(c != NULL);
if (c->msgcurr < c->msgused &&
c->msglist[c->msgcurr].msg_iovlen == 0) {
/* Finished writing the current msg; advance to the next. */
c->msgcurr++;
}
if (c->msgcurr < c->msgused) {
ssize_t res;
... | 236,802,833,718,325,200,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,375 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static enum try_read_result try_read_network(conn *c) {
enum try_read_result gotdata = READ_NO_DATA_RECEIVED;
int res;
int num_allocs = 0;
assert(c != NULL);
if (c->rcurr != c->rbuf) {
if (c->rbytes != 0) /* otherwise there's nothing to copy */
memmove(c->rbuf, c->rcurr, c->rbyt... | 2,988,142,678,645,857,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,376 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static enum try_read_result try_read_udp(conn *c) {
int res;
assert(c != NULL);
c->request_addr_size = sizeof(c->request_addr);
res = recvfrom(c->sfd, c->rbuf, c->rsize,
0, &c->request_addr, &c->request_addr_size);
if (res > 8) {
unsigned char *buf = (unsigned char *)c->... | 94,985,125,218,987,940,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,377 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static bool update_event(conn *c, const int new_flags) {
assert(c != NULL);
struct event_base *base = c->event.ev_base;
if (c->ev_flags == new_flags)
return true;
if (event_del(&c->event) == -1) return false;
event_set(&c->event, c->sfd, new_flags, event_handler, (void *)c);
event_base_... | 238,637,139,220,591,170,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,378 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void usage(void) {
printf(PACKAGE " " VERSION "\n");
printf("-p <num> TCP port number to listen on (default: 11211)\n"
"-U <num> UDP port number to listen on (default: 11211, 0 is off)\n"
"-s <file> UNIX socket path to listen on (disables network support)\n"
... | 56,183,369,214,808,480,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,379 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void usage_license(void) {
printf(PACKAGE " " VERSION "\n\n");
printf(
"Copyright (c) 2003, Danga Interactive, Inc. <http://www.danga.com/>\n"
"All rights reserved.\n"
"\n"
"Redistribution and use in source and binary forms, with or without\n"
"modification, are permitted provided tha... | 317,508,902,235,033,860,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,380 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void write_and_free(conn *c, char *buf, int bytes) {
if (buf) {
c->write_and_free = buf;
c->wcurr = buf;
c->wbytes = bytes;
conn_set_state(c, conn_write);
c->write_and_go = conn_new_cmd;
} else {
out_string(c, "SERVER_ERROR out of memory writing stats");
... | 328,669,922,345,948,100,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,381 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void write_bin_error(conn *c, protocol_binary_response_status err, int swallow) {
const char *errstr = "Unknown error";
size_t len;
switch (err) {
case PROTOCOL_BINARY_RESPONSE_ENOMEM:
errstr = "Out of memory";
break;
case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
err... | 196,651,437,378,409,450,000,000,000,000,000,000,000 | memcached.c | 54,711,639,671,296,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,382 | memcached | d9cd01ede97f4145af9781d448c62a3318952719 | https://github.com/memcached/memcached | http://github.com/memcached/memcached/commit/d9cd01ede97f4145af9781d448c62a3318952719 | Use strncmp when checking for large ascii multigets. | 0 | static void write_bin_response(conn *c, void *d, int hlen, int keylen, int dlen) {
if (!c->noreply || c->cmd == PROTOCOL_BINARY_CMD_GET ||
c->cmd == PROTOCOL_BINARY_CMD_GETK) {
add_bin_header(c, 0, hlen, keylen, dlen);
if(dlen > 0) {
add_iov(c, d, dlen);
}
conn_se... | 103,178,507,497,834,370,000,000,000,000,000,000,000 | memcached.c | 302,848,843,381,355,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2010-1152 | memcached.c in memcached before 1.4.3 allows remote attackers to cause a denial of service (daemon hang or crash) via a long line that triggers excessive memory allocation. NOTE: some of these details are obtained from third party information. | https://nvd.nist.gov/vuln/detail/CVE-2010-1152 |
21,383 | uzbl | 1958b52d41cba96956dc1995660de49525ed1047 | http://github.com/Dieterbe/uzbl | http://github.com/Dieterbe/uzbl/commit/1958b52d41cba96956dc1995660de49525ed1047 | disable Uzbl javascript object because of security problem. | 0 | assert_no_event (struct EventFixture *ef) {
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(ef->test_sock, &rfds);
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 0;
/* check if there's any data waiting */
int res = select(ef->test_sock + 1, &rfds, NULL, NULL, &timeout);
if(res... | 88,980,620,792,144,300,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2010-0011 | The eval_js function in uzbl-core.c in Uzbl before 2010.01.05 exposes the run method of the Uzbl object, which allows remote attackers to execute arbitrary commands via JavaScript code. | https://nvd.nist.gov/vuln/detail/CVE-2010-0011 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.