project
stringclasses 633
values | commit_id
stringlengths 7
81
| target
int64 0
1
| func
stringlengths 5
484k
| cwe
stringclasses 131
values | big_vul_idx
float64 0
189k
⌀ | idx
int64 0
522k
| hash
stringlengths 34
39
| size
float64 1
24k
⌀ | message
stringlengths 0
11.5k
⌀ | dataset
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
double date2serialdate(int day, int month, int year)
/* convert date to days since 1.1.1900 */
{
int serialdate;
serialdate = (int) ((1461 * (year + 4800 + (int) ((month - 14) / 12))) / 4) + (int) ((367 * (month - 2
-
12 *
((month -
14) /
12))) / 12) -
(int) ((3 * ((int) ((year + 4900 + (int) ((month - 14) / 12))
/ 100))) / 4) + day - 2415019 - 32075;
return serialdate;
}
|
CWE-79
| null | 519,427 |
7185534620774863476006640202668092784
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
int save_md5(LOGBOOK *lbs, char *server, MD5_INDEX *md5_index, int n) {
char str[256], url[256], file_name[256];
int i, j;
FILE *f;
combine_url(lbs, server, "", url, sizeof(url), NULL);
url_decode(url);
if (strstr(url, "http://"))
strlcpy(str, url + 7, sizeof(str));
else if (strstr(url, "https://"))
strlcpy(str, url + 8, sizeof(str));
else
strlcpy(str, url, sizeof(str));
for (i = 0; i < (int) strlen(str); i++)
if (strchr(":/\\ ", str[i]))
str[i] = '_';
while (str[strlen(str) - 1] == '_')
str[strlen(str) - 1] = 0;
strlcpy(file_name, logbook_dir, sizeof(file_name));
strlcat(file_name, str, sizeof(file_name));
strlcat(file_name, ".md5", sizeof(file_name));
f = fopen(file_name, "wt");
if (f == NULL)
return -1;
for (i = 0; i < n; i++) {
fprintf(f, "ID%d: ", md5_index[i].message_id);
for (j = 0; j < 16; j++)
fprintf(f, "%02X", md5_index[i].md5_digest[j]);
fprintf(f, "\n");
}
fclose(f);
return 1;
}
|
CWE-79
| null | 519,428 |
322236510156652098393409989319180372387
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
int msg_compare_reverse(const void *m1, const void *m2) {
return strcoll(((MSG_LIST *) m2)->string, ((MSG_LIST *) m1)->string);
}
|
CWE-79
| null | 519,429 |
116064627841388273899004453327431757328
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void do_crypt(const char *s, char *d, int size) {
strlcpy(d, sha256_crypt(s, "$5$") + 4, size);
}
|
CWE-79
| null | 519,430 |
60473535355491685894010049449019762747
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
int setuser(char *str) {
#ifdef OS_UNIX
struct passwd *pw;
pw = getpwnam(str);
if (pw != NULL)
if (setuid(pw->pw_uid) >= 0)
return 0;
else {
eprintf("Cannot set effective UID to user \"%s\"\n", str);
eprintf("setuser: %s\n", strerror(errno));
}
else
eprintf("User \"%s\" not found\n", str);
return -1;
#else
return 0;
#endif
}
|
CWE-79
| null | 519,431 |
61048393568355240915094218408156253176
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void format_email_text(LOGBOOK *lbs, char attrib[MAX_N_ATTR][NAME_LENGTH],
char att_file[MAX_ATTACHMENTS][256], int old_mail, char *url, char *multipart_boundary,
char *mail_text, int size) {
int i, j, k, flags, n_email_attr, attr_index[MAX_N_ATTR];
char str[NAME_LENGTH + 100], str2[256], mail_from[256], mail_from_name[256], format[256],
list[MAX_N_ATTR][NAME_LENGTH], comment[256], charset[256], heading[256],
slist[MAX_N_ATTR + 10][NAME_LENGTH], svalue[MAX_N_ATTR + 10][NAME_LENGTH];
time_t ltime;
struct tm *pts;
if (multipart_boundary[0]) {
if (!getcfg("global", "charset", charset, sizeof(charset)))
strcpy(charset, DEFAULT_HTTP_CHARSET);
strlcat(mail_text, "--", size);
strlcat(mail_text, multipart_boundary, size);
strlcat(mail_text, "\r\n", size);
sprintf(mail_text + strlen(mail_text), "Content-Type: text/plain; charset=%s; format=flowed\r\n",
charset);
sprintf(mail_text + strlen(mail_text), "Content-Transfer-Encoding: 7bit\r\n\r\n");
} else
strlcat(mail_text, "\r\n", size);
flags = 63;
if (getcfg(lbs->name, "Email format", str, sizeof(str)))
flags = atoi(str);
retrieve_email_from(lbs, mail_from, mail_from_name, attrib);
if (flags & 1) {
if (getcfg(lbs->name, "Use Email heading", heading, sizeof(heading))) {
if (old_mail) {
if (!getcfg(lbs->name, "Use Email heading edit", heading, sizeof(heading)))
getcfg(lbs->name, "Use Email heading", heading, sizeof(heading));
}
i = build_subst_list(lbs, slist, svalue, attrib, TRUE);
strsubst_list(heading, sizeof(heading), slist, svalue, i);
strlcpy(mail_text + strlen(mail_text), heading, size - strlen(mail_text));
} else {
if (old_mail)
strlcpy(mail_text + strlen(mail_text), loc("An old ELOG entry has been updated"),
size - strlen(mail_text));
else
strlcpy(mail_text + strlen(mail_text), loc("A new ELOG entry has been submitted"),
size - strlen(mail_text));
strcat(mail_text, ":");
}
strlcpy(mail_text + strlen(mail_text), "\r\n\r\n", size - strlen(mail_text));
}
if (flags & 32)
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Logbook"), lbs->name);
if (flags & 2) {
if (getcfg(lbs->name, "Email attributes", str, sizeof(str))) {
n_email_attr = strbreak(str, list, MAX_N_ATTR, ",", FALSE);
for (i = 0; i < n_email_attr; i++) {
for (j = 0; j < lbs->n_attr; j++)
if (strieq(attr_list[j], list[i]))
break;
if (!strieq(attr_list[j], list[i]))
/* attribute not found */
j = 0;
attr_index[i] = j;
}
} else {
for (i = 0; i < lbs->n_attr; i++)
attr_index[i] = i;
n_email_attr = lbs->n_attr;
}
for (j = 0; j < n_email_attr; j++) {
i = attr_index[j];
strcpy(str, " ");
memcpy(str, attr_list[i], strlen(attr_list[i]));
comment[0] = 0;
if (attr_flags[i] & AF_ICON) {
sprintf(str2, "Icon comment %s", attrib[i]);
getcfg(lbs->name, str2, comment, sizeof(comment));
} else if (attr_flags[i] & AF_DATE) {
sprintf(str, "Date format %s", attr_list[i]);
if (!getcfg(lbs->name, str, format, sizeof(format)))
if (!getcfg(lbs->name, "Date format", format, sizeof(format)))
strcpy(format, DEFAULT_DATE_FORMAT);
ltime = atoi(attrib[i]);
pts = localtime(<ime);
assert(pts);
if (ltime == 0)
strcpy(comment, "-");
else
my_strftime(comment, sizeof(str), format, pts);
} else if (attr_flags[i] & AF_DATETIME) {
sprintf(str, "Time format %s", attr_list[i]);
if (!getcfg(lbs->name, str, format, sizeof(format)))
if (!getcfg(lbs->name, "Time format", format, sizeof(format)))
strcpy(format, DEFAULT_TIME_FORMAT);
ltime = atoi(attrib[i]);
pts = localtime(<ime);
assert(pts);
if (ltime == 0)
strcpy(comment, "-");
else
my_strftime(comment, sizeof(str), format, pts);
}
if (!comment[0])
strcpy(comment, attrib[i]);
if (strieq(attr_options[i][0], "boolean"))
strcpy(comment, atoi(attrib[i]) ? "1" : "0");
for (k = strlen(str) - 1; k > 0; k--)
if (str[k] != ' ')
break;
if (k < 20)
sprintf(str + 20, ": %s\r\n", comment);
else
sprintf(str + k + 1, ": %s\r\n", comment);
strcpy(mail_text + strlen(mail_text), str);
}
}
if (flags & 4)
sprintf(mail_text + strlen(mail_text), "\r\n%s URL : %s\r\n", loc("Logbook"), url);
if (flags & 64) {
for (i = 0; i < MAX_ATTACHMENTS && att_file[i][0]; i++)
sprintf(mail_text + strlen(mail_text), "\r\n%s %d : %s (%s/%d)\r\n", loc("Attachment"),
i + 1, att_file[i] + 14, url, i + 1);
}
if (flags & 8) {
if (isparam("text")) {
sprintf(mail_text + strlen(mail_text), "\r\n=================================\r\n\r\n%s",
getparam("text"));
}
}
strlcat(mail_text, "\r\n\r\n", size);
}
|
CWE-79
| null | 519,432 |
34937735363571750857653269309077504853
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void redirect_to_syslog(void) {
static int has_inited = 0;
/* initiate syslog */
if (!has_inited) {
#ifdef OS_UNIX
setlogmask(LOG_UPTO(SYSLOG_PRIORITY));
openlog("elogd", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1);
#else
hEventLog = RegisterEventSource(NULL, "ELOG");
#endif
}
has_inited = 1;
printf_handler = print_syslog;
fputs_handler = fputs_syslog;
/* tells that the syslog facility is currently used as output */
current_output_stream = NULL;
}
|
CWE-79
| null | 519,433 |
72306276943592880461104856913385373136
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void rsprintf(const char *format, ...) {
va_list argptr;
char str[10000];
va_start(argptr, format);
vsprintf(str, (char *) format, argptr);
va_end(argptr);
if (strlen_retbuf + (int) strlen(str) + 1 >= return_buffer_size) {
return_buffer = xrealloc(return_buffer, return_buffer_size + 100000);
memset(return_buffer + return_buffer_size, 0, 100000);
return_buffer_size += 100000;
}
strcpy(return_buffer + strlen_retbuf, str);
strlen_retbuf += strlen(str);
}
|
CWE-79
| null | 519,434 |
21114776002674681746428391766195723306
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void show_rss_feed(LOGBOOK *lbs) {
int i, n, size, index, message_id, offset;
char str[256], charset[256], url[256], attrib[MAX_N_ATTR][NAME_LENGTH], date[80], *text, title[2000],
slist[MAX_N_ATTR + 10][NAME_LENGTH], svalue[MAX_N_ATTR + 10][NAME_LENGTH], draft[1000];
time_t ltime;
struct tm *ts;
rsprintf("HTTP/1.1 200 Document follows\r\n");
rsprintf("Server: ELOG HTTP %s-%s\r\n", VERSION, git_revision());
if (!getcfg("global", "charset", charset, sizeof(charset)))
strcpy(charset, DEFAULT_HTTP_CHARSET);
rsprintf("Content-Type: text/xml;charset=%s\r\n", charset);
rsprintf("\r\n");
rsprintf("<?xml version=\"1.0\" encoding=\"%s\"?>\n", charset);
rsprintf("<rss version=\"2.0\">\n");
rsprintf("<channel>\n");
rsprintf("<title>ELOG %s</title>\n", lbs->name);
/* retrive URL */
getcfg(lbs->name, "URL", url, sizeof(url));
/* if HTTP request comes from localhost, use localhost as
absolute link (needed if running on DSL at home) */
if (!url[0] && strstr(http_host, "localhost")) {
if (_ssl_flag)
strcpy(url, "https://localhost");
else
strcpy(url, "http://localhost");
if (elog_tcp_port != 80)
sprintf(url + strlen(url), ":%d", elog_tcp_port);
strcat(url, "/");
}
if (!url[0]) {
/* assemble absolute path from host name and port */
if (_ssl_flag)
sprintf(url, "https://%s", host_name);
else
sprintf(url, "http://%s", host_name);
if (elog_tcp_port != 80)
sprintf(url + strlen(url), ":%d", elog_tcp_port);
strcat(url, "/");
}
/* add trailing '/' if not present */
if (url[strlen(url) - 1] != '/')
strcat(url, "/");
strlcat(url, lbs->name_enc, sizeof(url));
rsprintf("<link>%s</link>\n", url);
if (getcfg(lbs->name, "Comment", str, sizeof(str))) {
rsprintf("<description>");
xmlencode(str);
rsprintf("</description>\n");
}
rsprintf("<generator>ELOG V%s</generator>\n", VERSION);
rsprintf("<image>\n");
rsprintf("<url>%s/elog.png</url>\n", url);
rsprintf("<title>ELOG %s</title>\n", lbs->name_enc);
rsprintf("<link>%s</link>\n", url);
rsprintf("</image>\n");
/*---- show last <n> items ----*/
n = 15;
if (getcfg(lbs->name, "RSS Entries", str, sizeof(str)))
n = atoi(str);
text = (char *) xmalloc(TEXT_SIZE);
message_id = el_search_message(lbs, EL_LAST, 0, FALSE);
for (index = 0; index < n && message_id; index++) {
size = TEXT_SIZE;
el_retrieve(lbs, message_id, date, attr_list, attrib, lbs->n_attr, text, &size, NULL, NULL,
NULL, NULL, NULL, draft);
/* skip drafts */
if (draft[0]) {
message_id = el_search_message(lbs, EL_PREV, message_id, FALSE);
continue;
}
/* limit text size to 2k */
text[2048] = 0;
if (getcfg(lbs->name, "RSS Title", title, sizeof(title))) {
i = build_subst_list(lbs, (char (*)[NAME_LENGTH]) slist, (char (*)[NAME_LENGTH]) svalue, attrib,
TRUE);
sprintf(str, "%d", message_id);
add_subst_list((char (*)[NAME_LENGTH]) slist, (char (*)[NAME_LENGTH]) svalue, "message id", str, &i);
add_subst_time(lbs, (char (*)[NAME_LENGTH]) slist, (char (*)[NAME_LENGTH]) svalue, "entry time",
date, &i, 0);
strsubst_list(title, sizeof(title), (char (*)[NAME_LENGTH]) slist, (char (*)[NAME_LENGTH]) svalue,
i);
} else {
title[0] = 0;
for (i = 0; i < lbs->n_attr; i++) {
if (attrib[i][0]) {
strlcat(title, attrib[i], sizeof(title));
if (i < lbs->n_attr - 1)
strlcat(title, ", ", sizeof(title));
}
}
}
rsprintf("<item>\n");
/* convert date to RFC-822 date */
setlocale(LC_ALL, "C");
ltime = date_to_ltime(date);
ts = localtime(<ime);
assert(ts);
strftime(str, sizeof(str), "%a, %d %b %Y %H:%M:%S", ts);
offset = (-(int) my_timezone());
if (ts->tm_isdst)
offset += 3600;
snprintf(date, sizeof(date) - 1, "%s %+03d%02d", str, (int) (offset / 3600), (int) ((abs((int) offset)
/ 60) % 60));
getcfg("global", "Language", str, sizeof(str));
if (str[0])
setlocale(LC_ALL, str);
rsprintf("<title>");
xmlencode(title);
rsprintf("</title>\n");
rsprintf("<link>");
strlcpy(str, url, sizeof(str));
sprintf(str + strlen(str), "/%d", message_id);
xmlencode(str);
rsprintf("</link>\n");
rsprintf("<description>\n");
xmlencode(text);
rsprintf("</description>\n");
rsprintf("<pubDate>\n");
rsprintf("%s", date);
rsprintf("</pubDate>\n");
rsprintf("</item>\n");
message_id = el_search_message(lbs, EL_PREV, message_id, FALSE);
}
xfree(text);
rsprintf("</channel>\n");
rsprintf("</rss>\n");
}
|
CWE-79
| null | 519,435 |
314258505437854591774252906844532943795
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void show_standard_header(LOGBOOK *lbs, BOOL expires, char *title, char *path, BOOL rss_feed, char *cookie,
char *script, int refresh) {
if (script) {
show_html_header(lbs, expires, title, FALSE, rss_feed, cookie, FALSE, refresh);
rsprintf("<script type=\"text/javascript\">\n");
rsprintf("<!--\n");
show_browser(browser);
rsprintf("logbook = \"%s\";\n", lbs->name_enc);
rsprintf("//-->\n");
rsprintf("</script>\n");
rsprintf("<script type=\"text/javascript\" src=\"../elcode.js\"></script>\n\n");
rsprintf("</head>\n");
} else
show_html_header(lbs, expires, title, TRUE, rss_feed, cookie, FALSE, refresh);
if (script)
rsprintf("<body %s>\n", script);
else
rsprintf("<body>\n");
show_top_text(lbs);
if (path && path[0])
rsprintf("<form name=\"form1\" method=\"GET\" action=\"%s\">\n\n", path);
else
rsprintf("<form name=\"form1\" method=\"GET\" action=\".\">\n\n");
}
|
CWE-79
| null | 519,436 |
325389145344534604170306836218987247555
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
int check_drafts(LOGBOOK *lbs) {
time_t now;
char str[1000], draft[256], title[256], datetime[256], attrib[MAX_N_ATTR][NAME_LENGTH];
int i, n_draft, *draft_id = NULL;
/* if we got here already and user clicked "Create new entry", ignore is set and we skip this */
if (isparam("ignore"))
return 0;
time(&now);
/* check if any recent draft */
for (i = n_draft = 0; i < *(lbs->n_el_index); i++)
if (lbs->el_index[i].file_time > now - 3600 * 24 * 7) { // only one week to reduce seek time
el_retrieve(lbs, lbs->el_index[i].message_id, NULL, attr_list, attrib, lbs->n_attr,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, draft);
if (draft[0] && is_author(lbs, attrib, draft)) {
if (n_draft == 0)
draft_id = (int *) xmalloc(sizeof(int));
else
draft_id = (int *) xrealloc(draft_id, sizeof(int) * (n_draft + 1));
draft_id[n_draft] = lbs->el_index[i].message_id;
n_draft++;
}
}
if (n_draft == 0)
return 0;
if (n_draft == 1)
sprintf(title, "%s", loc("Pending draft available"));
else
sprintf(title, loc("%d pending drafts available"), n_draft);
show_standard_header(lbs, TRUE, "Draft query", NULL, FALSE, NULL, NULL, 0);
rsprintf("<table class=\"dlgframe\" cellspacing=0 align=center>\n");
rsprintf("<tr><td colspan=\"2\" class=\"dlgtitle\">");
rsprintf("%s</td></tr>\n", title);
for (i = 0; i < n_draft; i++) {
el_retrieve(lbs, draft_id[i], datetime, NULL, NULL, 0, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, draft);
rsprintf("<tr><td class=\"draftsel\" align=\"center\">");
sprintf(str, loc("Draft entry created on %s by %s"), datetime, draft);
rsprintf("%s</td>\n", str);
rsprintf("<td class=\"draftsel\">");
rsprintf("<input type=button value=\"%s\" onClick=\"window.location.href='%d?cmd=%s';\">",
loc("Edit"), draft_id[i], loc("Edit"));
rsprintf("</td></tr>\n");
}
rsprintf("<tr><td colspan=\"2\" align=center class=\"dlgform\">");
rsprintf("<input type=button value=\"%s\" onClick=\"window.location.href='?cmd=%s&ignore=1';\">\n",
loc("Create new entry"),
loc("New"));
rsprintf("</td></tr>\n\n");
rsprintf("</table>\n");
show_bottom_text(lbs);
rsprintf("</body></html>\r\n");
xfree(draft_id);
return 1;
}
|
CWE-79
| null | 519,437 |
253008029040088009746897058433448797207
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
BOOL is_author(LOGBOOK *lbs, char attrib[MAX_N_ATTR][NAME_LENGTH], char *owner) {
char str[NAME_LENGTH], preset[NAME_LENGTH], full_name[NAME_LENGTH];
int i;
/* check if current user is admin */
if (is_admin_user(lbs, getparam("unm")))
return TRUE;
/* search attribute which contains short_name of author */
for (i = 0; i < lbs->n_attr; i++) {
sprintf(str, "Preset %s", attr_list[i]);
if (getcfg(lbs->name, str, preset, sizeof(preset))) {
if (strstr(preset, "$short_name")) {
if (!isparam("unm") || strstr(attrib[i], getparam("unm")) == NULL) {
strcpy(owner, attrib[i]);
return FALSE;
} else
break;
}
}
}
if (i == lbs->n_attr) {
/* if not found, search attribute which contains full_name of author */
if (isparam("unm")) {
get_full_name(lbs, getparam("unm"), full_name);
for (i = 0; i < lbs->n_attr; i++) {
sprintf(str, "Preset %s", attr_list[i]);
if (getcfg(lbs->name, str, preset, sizeof(preset))) {
if (strstr(preset, "$long_name")) {
if (strstr(attrib[i], full_name) == NULL) {
strcpy(owner, attrib[i]);
return FALSE;
} else
break;
}
}
}
}
}
return TRUE;
}
|
CWE-79
| null | 519,438 |
157166577626207127371585574120473133570
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void stou(char *str)
/* convert all special characters to underscores in a string */
{
int i;
for (i = 0; i < (int) strlen(str); i++)
if (!isalnum(str[i]))
str[i] = '_';
}
|
CWE-79
| null | 519,439 |
163369487749395322056750699958157583818
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
BOOL strieq(const char *str1, const char *str2) {
char c1, c2;
if (str1 == NULL && str2 == NULL)
return TRUE;
if (str1 == NULL || str2 == NULL)
return FALSE;
if (strlen(str1) != strlen(str2))
return FALSE;
while (*str1) {
c1 = *str1++;
c2 = *str2++;
if (my_toupper(c1) != my_toupper(c2))
return FALSE;
}
if (*str2)
return FALSE;
return TRUE;
}
|
CWE-79
| null | 519,440 |
309656453509842090334785868454993414781
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
time_t convert_date(char *date_string) {
/* convert date string in MM/DD/YY or DD.MM.YY format into Unix time */
int year, month, day;
char *p, str[256];
struct tm tms;
time_t ltime;
strlcpy(str, date_string, sizeof(str));
month = day = year = 0;
if (strchr(str, '[')) {
ltime = atoi(strchr(str, '[') + 1);
return ltime;
} else if (strchr(str, '/')) {
/* MM/DD/YY format */
p = strtok(str, "/");
if (p) {
month = atoi(p);
p = strtok(NULL, "/");
if (p) {
day = atoi(p);
p = strtok(NULL, "/");
if (p)
year = atoi(p);
}
}
} else if (strchr(str, '.')) {
/* DD.MM.YY format */
p = strtok(str, ".");
if (p) {
day = atoi(p);
p = strtok(NULL, ".");
if (p) {
month = atoi(p);
p = strtok(NULL, ".");
if (p)
year = atoi(p);
}
}
} else
return 0;
/* calculate years */
if (year > 1900) /* 1900-2100 */
year += 0;
else if (year < 70) /* 00-69 */
year += 2000;
else if (year < 100) /* 70-99 */
year += 1900;
/* use last day of month */
memset(&tms, 0, sizeof(struct tm));
tms.tm_year = year - 1900;
tms.tm_mon = month - 1;
tms.tm_mday = day;
tms.tm_hour = 12;
ltime = mktime(&tms);
return ltime;
}
|
CWE-79
| null | 519,441 |
333248606042729773623194703088091937704
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void set_verbose(int v) {
_verbose_level = v;
}
|
CWE-79
| null | 519,442 |
283523976293366201809804275160879838340
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
char *xstrdup(const char *string) {
char *s;
s = (char *) xmalloc(strlen(string) + 1);
strcpy(s, string);
return s;
}
|
CWE-79
| null | 519,443 |
295539716860003478188826738489149006042
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void show_find_form(LOGBOOK *lbs) {
int i, j, year, month, day, flag;
char str[NAME_LENGTH], mode[NAME_LENGTH], comment[NAME_LENGTH], option[NAME_LENGTH], login_name[256],
full_name[256], user_email[256], enc_attr[NAME_LENGTH], whole_attr[NAME_LENGTH],
attrib[MAX_N_ATTR][NAME_LENGTH];
/*---- header ----*/
show_standard_header(lbs, FALSE, loc("ELOG find"), NULL, FALSE, NULL, NULL, 0);
/*---- title ----*/
show_standard_title(lbs, "", 0);
/*---- menu buttons ----*/
rsprintf("<tr><td class=\"menuframe\"><span class=\"menu1\">\n");
rsprintf("<input type=submit value=\"%s\">\n", loc("Search"));
rsprintf("<input type=reset value=\"%s\">\n", loc("Reset Form"));
rsprintf("<input type=submit name=cmd value=\"%s\">\n", loc("Back"));
rsprintf("<input type=hidden name=jcmd value=\"\">\n");
rsprintf("</span></td></tr>\n\n");
/*---- evaluate conditional attributes ----*/
for (i = 0; i < lbs->n_attr; i++)
attrib[i][0] = 0;
/* get attributes from parameters */
attrib_from_param(lbs->n_attr, attrib);
evaluate_conditions(lbs, attrib);
/*---- entry form ----*/
rsprintf("<tr><td class=\"form1\"><table><tr><td valign=\"top\" class=\"form1\">\n");
rsprintf("<b>%s:</b><br>", loc("Mode"));
if (!getcfg(lbs->name, "Display mode", mode, sizeof(mode)))
strcpy(mode, "Full");
if (!getcfg(lbs->name, "Show text", str, sizeof(str)) || atoi(str) == 1) {
if (strieq(mode, "Full"))
rsprintf("<input type=radio id=\"full\" name=\"mode\" value=\"full\" checked>");
else
rsprintf("<input type=radio id=\"full\" name=\"mode\" value=\"full\">");
rsprintf("<label for=\"full\">%s </label><br>\n", loc("Display full entries"));
if (strieq(mode, "Summary"))
rsprintf("<input type=radio id=\"summary\" name=\"mode\" value=\"summary\" checked>");
else
rsprintf("<input type=radio id=\"summary\" name=\"mode\" value=\"summary\">");
rsprintf("<label for=\"summary\">%s </label><br>\n", loc("Summary only"));
} else {
if (strieq(mode, "Full") || strieq(mode, "Summary"))
rsprintf("<input type=radio id=\"summary\" name=\"mode\" value=\"summary\" checked>");
else
rsprintf("<input type=radio id=\"summary\" name=\"mode\" value=\"summary\">");
rsprintf("<label for=\"summary\">%s </label><br>\n", loc("Summary"));
}
if (strieq(mode, "Threaded"))
rsprintf("<input type=radio id=\"threaded\" name=\"mode\" value=\"threaded\" checked>");
else
rsprintf("<input type=radio id=\"threaded\" name=\"mode\" value=\"threaded\">");
rsprintf("<label for=\"threaded\">%s </label>\n", loc("Display threads"));
rsprintf("</td><td valign=\"top\" class=\"form1\"><b>%s:</b><br>", loc("Export to"));
if (strieq(mode, "CSV1"))
rsprintf("<input type=radio id=\"CSV1\" name=\"mode\" value=\"CSV1\" checked>");
else
rsprintf("<input type=radio id=\"CSV1\" name=\"mode\" value=\"CSV1\">");
rsprintf("<label for=\"CSV1\">%s </label><br>\n", loc("CSV (\",\" separated)"));
if (strieq(mode, "CSV2"))
rsprintf("<input type=radio id=\"CSV2\" name=\"mode\" value=\"CSV2\" checked>");
else
rsprintf("<input type=radio id=\"CSV2\" name=\"mode\" value=\"CSV2\">");
rsprintf("<label for=\"CSV2\">%s </label><br>\n", loc("CSV (\";\" separated)"));
if (strieq(mode, "CSV3"))
rsprintf("<input type=radio id=\"CSV3\" name=\"mode\" value=\"CSV3\" checked>");
else
rsprintf("<input type=radio id=\"CSV3\" name=\"mode\" value=\"CSV3\">");
rsprintf("<label for=\"CSV3\">%s </label><br>\n", loc("CSV (\";\" separated) + Text"));
if (strieq(mode, "XML"))
rsprintf("<input type=radio id=\"XML\" name=\"mode\" value=\"XML\" checked>");
else
rsprintf("<input type=radio id=\"XML\" name=\"mode\" value=\"XML\">");
rsprintf("<label for=\"XML\">XML </label><br>\n");
if (strieq(mode, "Raw"))
rsprintf("<input type=radio id=\"Raw\" name=\"mode\" value=\"Raw\" checked>");
else
rsprintf("<input type=radio id=\"Raw\" name=\"mode\" value=\"Raw\">");
rsprintf("<label for=\"Raw\">Raw </label><br>\n");
rsprintf("</td>\n");
rsprintf("<td valign=\"top\" class=\"form2\"><b>%s:</b><br>", loc("Options"));
rsprintf("<input type=checkbox id=\"attach\" name=\"attach\" value=1>");
rsprintf("<label for=\"attach\">%s<br></label>\n", loc("Show attachments"));
rsprintf("<input type=checkbox id=\"printable\" name=\"printable\" value=1>");
rsprintf("<label for=\"printable\">%s<br></label>\n", loc("Printable output"));
/* put hidden reverse=0, which gets used if the reverse checkbox is unchecked and "reverse sort=1" is in elogd.cfg */
rsprintf("<input type=hidden name=\"reverse\" value=0>\n");
if (getcfg(lbs->name, "Reverse sort", str, sizeof(str)) && atoi(str) == 1)
rsprintf("<input type=checkbox id=\"reverse\" name=\"reverse\" value=1 checked>");
else
rsprintf("<input type=checkbox id=\"reverse\" name=\"reverse\" value=1>");
rsprintf("<label for=\"reverse\">%s<br></label>\n", loc("Sort in reverse order"));
/* count logbooks */
for (i = 0;; i++) {
if (!enumgrp(i, str))
break;
if (is_logbook(str))
continue;
}
if (i > 2) {
if (!getcfg(lbs->name, "Search all logbooks", str, sizeof(str)) || atoi(str) == 1 || atoi(str) == 2) {
if (atoi(str) == 2)
rsprintf("<input type=checkbox checked id=all name=all value=1>");
else
rsprintf("<input type=checkbox id=all name=all value=1>");
rsprintf("<label for=\"all\">%s</label><br>\n", loc("Search all logbooks"));
}
}
rsprintf(loc("Display"));
if (!getcfg(lbs->name, "Entries per page", str, sizeof(str)))
strcpy(str, "20");
rsprintf(" <input type=text name=npp size=3 value=%s> ", str);
rsprintf(loc("entries per page"));
rsprintf("</td></tr></table></td></tr>\n");
rsprintf("<tr><td class=\"form2\"><b>%s:</b>", loc("Filters"));
sprintf(str, "<a href=\"http://dmoz.org/Computers/Programming/Languages/Regular_Expressions/\">");
strcat(str, loc("regular expressions"));
strcat(str, "</a>");
rsprintf(" <span class=\"selcomment\">(");
rsprintf(loc("Text fields are treated as %s"), str);
rsprintf(")</span><br>");
/* table for two-column items */
rsprintf("<table width=\"100%%\" cellspacing=0>\n");
rsprintf("<tr><td class=\"attribname\" nowrap width=\"10%%\">%s:</td>", loc("Entry date"));
rsprintf("<td class=\"attribvalue\"><table width=\"100%%\" cellspacing=0 border=0>\n");
rsprintf("<tr><td width=\"1%%\">%s:<td>", loc("Start"));
year = month = day = 0;
sprintf(str, "ya");
if (isparam(str))
year = atoi(getparam(str));
sprintf(str, "ma");
if (isparam(str))
month = atoi(getparam(str));
sprintf(str, "da");
if (isparam(str))
day = atoi(getparam(str));
show_date_selector(day, month, year, "a");
rsprintf(" ");
show_time_selector(-1, -1, -1, "a");
rsprintf(" / %s: ", loc("Show last"));
if (getcfg(lbs->name, "Show last default", str, sizeof(str)))
i = atoi(str);
else
i = 0;
rsprintf("<select name=last>\n");
if (i > 0)
rsprintf("<option value=\"\">%s\n", loc("All time"));
else
rsprintf("<option value=\"\">\n");
rsprintf("<option %svalue=1>%s\n", i == 1 ? "selected " : "", loc("Day"));
rsprintf("<option %svalue=3>%s\n", i == 3 ? "selected " : "", loc("3 Days"));
rsprintf("<option %svalue=7>%s\n", i == 7 ? "selected " : "", loc("Week"));
rsprintf("<option %svalue=31>%s\n", i == 31 ? "selected " : "", loc("Month"));
rsprintf("<option %svalue=92>%s\n", i == 92 ? "selected " : "", loc("3 Months"));
rsprintf("<option %svalue=182>%s\n", i == 182 ? "selected " : "", loc("6 Months"));
rsprintf("<option %svalue=364>%s\n", i == 364 ? "selected " : "", loc("Year"));
rsprintf("</select> \n");
rsprintf("</td></tr>\n");
rsprintf("<tr><td width=\"1%%\">%s:<td>", loc("End"));
year = month = day = 0;
sprintf(str, "yb");
if (isparam(str))
year = atoi(getparam(str));
sprintf(str, "mb");
if (isparam(str))
month = atoi(getparam(str));
sprintf(str, "db");
if (isparam(str))
day = atoi(getparam(str));
show_date_selector(day, month, year, "b");
rsprintf(" ");
show_time_selector(-1, -1, -1, "b");
rsprintf("</td></tr></table></td></tr>\n");
for (i = 0; i < lbs->n_attr; i++) {
rsprintf("<tr><td class=\"attribname\" nowrap>%s:</td>", attr_list[i]);
rsprintf("<td class=\"attribvalue\">");
if (attr_options[i][0][0] == 0) {
if (attr_flags[i] & (AF_DATE | AF_DATETIME)) {
rsprintf("<table width=\"100%%\" cellspacing=0 border=0>\n");
rsprintf("<tr><td width=\"1%%\">%s:<td>", loc("Start"));
year = month = day = 0;
sprintf(str, "y%da", i);
if (isparam(str))
year = atoi(getparam(str));
sprintf(str, "m%da", i);
if (isparam(str))
month = atoi(getparam(str));
sprintf(str, "d%da", i);
if (isparam(str))
day = atoi(getparam(str));
sprintf(str, "%da", i);
show_date_selector(day, month, year, str);
if (attr_flags[i] & AF_DATETIME) {
rsprintf(" ");
show_time_selector(-1, -1, -1, str);
}
rsprintf("</td></tr>\n");
rsprintf("<tr><td width=\"1%%\">%s:<td>", loc("End"));
year = month = day = 0;
sprintf(str, "y%db", i);
if (isparam(str))
year = atoi(getparam(str));
sprintf(str, "m%db", i);
if (isparam(str))
month = atoi(getparam(str));
sprintf(str, "d%db", i);
if (isparam(str))
day = atoi(getparam(str));
sprintf(str, "%db", i);
show_date_selector(day, month, year, str);
if (attr_flags[i] & AF_DATETIME) {
rsprintf(" ");
show_time_selector(-1, -1, -1, str);
}
rsprintf("</td></tr></table>\n");
} else if (attr_flags[i] & AF_MUSERLIST) {
for (j = 0;; j++) {
if (!enum_user_line(lbs, j, login_name, sizeof(login_name)))
break;
get_user_line(lbs, login_name, NULL, full_name, NULL, NULL, NULL, NULL);
sprintf(str, "%s_%d", attr_list[i], j);
rsprintf("<nobr><input type=checkbox id=\"%s\" name=\"%s\" value=\"%s\"\">\n", str, str,
full_name);
rsprintf("<label for=\"%s\">%s</label></nobr>\n", str, full_name);
}
} else if (attr_flags[i] & AF_MUSEREMAIL) {
for (j = 0;; j++) {
if (!enum_user_line(lbs, j, login_name, sizeof(login_name)))
break;
get_user_line(lbs, login_name, NULL, NULL, user_email, NULL, NULL, NULL);
sprintf(str, "%s_%d", attr_list[i], j);
rsprintf("<nobr><input type=checkbox id=\"%s\" name=\"%s\" value=\"%s\"\">\n", str, str,
user_email);
rsprintf("<label for=\"%s\">%s</label></nobr>\n", str, user_email);
}
} else {
rsprintf("<input type=\"text\" size=\"30\" maxlength=\"80\" name=\"%s\" value=\"%s\">\n",
attr_list[i], attrib[i]);
}
} else {
if (strieq(attr_options[i][0], "boolean")) {
if (isparam(attr_list[i]) && *getparam(attr_list[i]))
flag = atoi(getparam(attr_list[i]));
else
flag = -1;
sprintf(str, "%s_0", attr_list[i]);
rsprintf("<span style=\"white-space:nowrap;\">\n");
if (flag == 0)
rsprintf("<input type=radio checked id=\"%s\" name=\"%s\" value=\"0\">\n", str, attr_list[i]);
else
rsprintf("<input type=radio id=\"%s\" name=\"%s\" value=\"0\">\n", str, attr_list[i]);
rsprintf("<label for=\"%s\">0</label>\n", str);
rsprintf("</span>\n");
sprintf(str, "%s_1", attr_list[i]);
rsprintf("<span style=\"white-space:nowrap;\">\n");
if (flag == 1)
rsprintf("<input type=radio checked id=\"%s\" name=\"%s\" value=\"1\">\n", str, attr_list[i]);
else
rsprintf("<input type=radio id=\"%s\" name=\"%s\" value=\"1\">\n", str, attr_list[i]);
rsprintf("<label for=\"%s\">1</label>\n", str);
rsprintf("</span>\n");
sprintf(str, "%s_2", attr_list[i]);
rsprintf("<span style=\"white-space:nowrap;\">\n");
if (flag == -1)
rsprintf("<input type=radio checked id=\"%s\" name=\"%s\" value=\"\">\n", str, attr_list[i]);
else
rsprintf("<input type=radio id=\"%s\" name=\"%s\" value=\"\">\n", str, attr_list[i]);
rsprintf("<label for=\"%s\">%s</label>\n", str, loc("unspecified"));
rsprintf("</span>\n");
}
/* display image for icon */
else if (attr_flags[i] & AF_ICON) {
for (j = 0; j < MAX_N_LIST && attr_options[i][j][0]; j++) {
strcpy(option, attr_options[i][j]);
if (strchr(option, '{'))
*strchr(option, '{') = 0;
sprintf(str, "Icon comment %s", option);
getcfg(lbs->name, str, comment, sizeof(comment));
if (comment[0] == 0)
strcpy(comment, option);
rsprintf("<nobr><input type=radio name=\"%s\" value=\"%s\">", attr_list[i], comment);
rsprintf("<img src=\"icons/%s\" alt=\"%s\" title=\"%s\"></nobr>\n", option, comment, comment);
}
}
/* display check boxes (or'ed) */
else if (attr_flags[i] & AF_MULTI) {
for (j = 0; j < MAX_N_LIST && attr_options[i][j][0]; j++) {
sprintf(str, "%s_%d", attr_list[i], j);
if (isparam(str))
rsprintf("<nobr><input type=checkbox checked id=\"%s\" name=\"%s\" value=\"%s\"\">\n",
str, str, attr_options[i][j]);
else
rsprintf("<nobr><input type=checkbox id=\"%s\" name=\"%s\" value=\"%s\"\">\n",
str, str, attr_options[i][j]);
rsprintf("<label for=\"%s\">%s</label></nobr>\n", str, attr_options[i][j]);
}
} else {
rsprintf("<select name=\"%s\"", attr_list[i]);
if (is_cond_attr(i))
rsprintf(" onChange=\"document.form1.jcmd.value='Find';document.form1.submit();\"");
rsprintf(">\n");
rsprintf("<option value=\"\">\n");
for (j = 0; j < MAX_N_LIST && attr_options[i][j][0]; j++) {
strencode2(str, attr_options[i][j], sizeof(str));
if (strchr(str, '{'))
*strchr(str, '{') = 0;
strencode2(enc_attr, attrib[i], sizeof(enc_attr));
sprintf(whole_attr, "^%s$", str);
if (strieq(attr_options[i][j], attrib[i]) || strieq(str, enc_attr)
|| strieq(whole_attr, enc_attr))
rsprintf("<option selected value=\"^%s$\">%s\n", str, str);
else
rsprintf("<option value=\"^%s$\">%s\n", str, str);
}
rsprintf("</select>\n");
}
}
rsprintf("</td></tr>\n");
}
rsprintf("<tr><td class=\"attribname\">%s:</td>", loc("Text"));
rsprintf("<td class=\"attribvalue\">\n");
if (isparam("subtext"))
strlcpy(str, getparam("subtext"), sizeof(str));
else
str[0] = 0;
rsprintf("<input type=\"text\" size=\"30\" maxlength=\"80\" name=\"subtext\" value=\"%s\">\n", str);
rsprintf("<input type=checkbox id=\"sall\" name=\"sall\" value=1>\n");
rsprintf("<label for=\"sall\">%s</label>\n", loc("Search text also in attributes"));
rsprintf("<tr><td><td class=\"attribvalue\">\n");
if (getcfg(lbs->name, "Case sensitive search", str, sizeof(str)) && atoi(str))
rsprintf("<input type=checkbox id=\"sall\" name=\"casesensitive\" value=1 checked>\n");
else
rsprintf("<input type=checkbox id=\"sall\" name=\"casesensitive\" value=1>\n");
rsprintf("<label for=\"casesensitive\">%s</label>\n", loc("Case sensitive"));
rsprintf("</td></tr></table></td></tr></table>\n");
show_bottom_text(lbs);
rsprintf("</form></body></html>\r\n");
}
|
CWE-79
| null | 519,444 |
264445870566685497095744204028415544534
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void synchronize_logbook(LOGBOOK *lbs, int mode, BOOL sync_all) {
int index, i, j, i_msg, i_remote, i_cache, n_remote, n_cache, nserver, remote_id, exist_remote,
exist_cache, message_id, max_id, ssl;
int all_identical, n_delete;
char str[2000], url[256], loc_ref[256], rem_ref[256], pwd[256], locked_by[256], draft[256];
MD5_INDEX *md5_remote, *md5_cache;
char list[MAX_N_LIST][NAME_LENGTH], error_str[256], *buffer;
unsigned char digest[16];
if (!getcfg(lbs->name, "Mirror server", str, sizeof(str))) {
show_error(loc("No mirror server defined in configuration file"));
return;
}
nserver = strbreak(str, list, MAX_N_LIST, ",", FALSE);
for (index = 0; index < nserver; index++) {
if (mode == SYNC_HTML) {
rsprintf("<table width=\"100%%\" cellpadding=\"1\" cellspacing=\"0\"");
if (getcfg_topgroup())
sprintf(loc_ref, "<a href=\"../%s/\">%s</a>", lbs->name_enc, lbs->name);
else if (sync_all)
sprintf(loc_ref, "<a href=\"%s/\">%s</a>", lbs->name_enc, lbs->name);
else
sprintf(loc_ref, "<a href=\".\">%s</a>", lbs->name);
sprintf(str, loc("Synchronizing logbook %s with server \"%s\""), loc_ref, list[index]);
rsprintf("<tr><td class=\"title1\">%s</td></tr>\n", str);
rsprintf("</table><p>\n");
rsprintf("<pre>");
} else if (mode == SYNC_CLONE) {
if (list[index][strlen(list[index]) - 1] != '/')
eprintf("\nRetrieving entries from \"%s/%s\"...\n", list[index], lbs->name);
else
eprintf("\nRetrieving entries from \"%s%s\"...\n", list[index], lbs->name);
}
/* send partial return buffer */
flush_return_buffer();
do {
n_remote = retrieve_remote_md5(lbs, list[index], &md5_remote, error_str);
if (n_remote <= 0) {
if ((n_remote == -2 || n_remote == -3) && mode == SYNC_CLONE) {
if (n_remote == -3)
eprintf("\nInvalid username or password.");
combine_url(lbs, list[index], "", url, sizeof(url), NULL);
/* ask for username and password */
eprintf("\nPlease enter username to access\n%s: ", url);
fgets(str, sizeof(str), stdin);
while (str[strlen(str) - 1] == '\r' || str[strlen(str) - 1] == '\n')
str[strlen(str) - 1] = 0;
setparam("unm", str);
eprintf("\nPlease enter password to access\n%s: ", url);
read_password(str, sizeof(str));
eprintf("\n");
while (str[strlen(str) - 1] == '\r' || str[strlen(str) - 1] == '\n')
str[strlen(str) - 1] = 0;
do_crypt(str, pwd, sizeof(pwd));
setparam("upwd", pwd);
} else {
mprint(lbs, mode, error_str);
if (md5_remote)
xfree(md5_remote);
if (mode == SYNC_HTML)
rsprintf("</pre>\n");
break;
}
}
} while (n_remote <= 0);
if (n_remote <= 0)
continue;
/* load local copy of remote MD5s from file */
n_cache = load_md5(lbs, list[index], &md5_cache);
all_identical = TRUE;
/*---- check for configuration file ----*/
if (getcfg(lbs->name, "Mirror config", str, sizeof(str)) && atoi(str) == 1 && md5_cache && mode
!=
SYNC_CLONE) {
load_config_section(lbs->name, &buffer, error_str);
if (error_str[0])
mprint(lbs, mode, error_str);
else {
remove_crlf(buffer);
MD5_checksum(buffer, strlen(buffer), digest);
}
/* compare MD5s */
if (get_verbose() >= VERBOSE_INFO) {
eprintf("CONFIG : ");
for (j = 0; j < 16; j++)
eprintf("%02X", digest[j]);
eprintf("\nCache : ");
for (j = 0; j < 16; j++)
eprintf("%02X", md5_cache[0].md5_digest[j]);
eprintf("\nRemote : ");
for (j = 0; j < 16; j++)
eprintf("%02X", md5_remote[0].md5_digest[j]);
eprintf("\n\n");
}
if (n_remote > 0) {
/* if config has been changed on this server, but not remotely, send it */
if (!equal_md5(md5_cache[0].md5_digest, digest) && equal_md5(md5_cache[0].md5_digest,
md5_remote[0].md5_digest)) {
all_identical = FALSE;
if (_logging_level > 1)
write_logfile(lbs, "MIRROR send config");
/* submit configuration section */
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
submit_config(lbs, list[index], buffer, error_str);
if (error_str[0])
mprint(lbs, mode, error_str);
else
mprint(lbs, mode, "Local config submitted");
md5_cache[0].message_id = -1;
} else
mprint(lbs, mode, "Local config should be submitted");
} else
/* if config has been changed remotely, but not on this server, receive it */
if (!equal_md5(md5_cache[0].md5_digest, md5_remote[0].md5_digest)
&& equal_md5(md5_cache[0].md5_digest, digest)) {
all_identical = FALSE;
if (_logging_level > 1)
write_logfile(lbs, "MIRROR receive config");
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
receive_config(lbs, list[index], error_str);
if (error_str[0])
mprint(lbs, mode, error_str);
else
mprint(lbs, mode, "Remote config received");
md5_cache[0].message_id = -1;
} else
mprint(lbs, mode, loc("Remote config should be received"));
} else
/* if config has been changed remotely and on this server, show conflict */
if (!equal_md5(md5_cache[0].md5_digest, md5_remote[0].md5_digest)
&& !equal_md5(md5_cache[0].md5_digest, digest)
&& !equal_md5(md5_remote[0].md5_digest, digest)) {
if (_logging_level > 1)
write_logfile(lbs, "MIRROR config conflict");
sprintf(str, "%s. ", loc("Configuration has been changed locally and remotely"));
strcat(str, loc("Please merge manually to resolve conflict"));
strcat(str, ".");
mprint(lbs, mode, str);
} else {
/* configs are identical */
md5_cache[0].message_id = -1;
}
} else { /* n_remote == 0 */
sprintf(str, loc("Logbook \"%s\" does not exist on remote server"), lbs->name);
mprint(lbs, mode, str);
continue;
}
flush_return_buffer();
if (buffer)
xfree(buffer);
}
/*---- loop through logbook entries ----*/
n_delete = 0;
for (i_msg = 0; i_msg < *lbs->n_el_index; i_msg++) {
message_id = lbs->el_index[i_msg].message_id;
/* check if message is locked */
el_retrieve(lbs, message_id, NULL, NULL, NULL, 0, NULL, 0, NULL, NULL, NULL, NULL, locked_by, draft);
if (locked_by[0]) {
sprintf(str, "ID%d:\t%s", message_id,
loc("Entry is locked on local server and therefore skipped"));
mprint(lbs, mode, str);
all_identical = FALSE;
continue;
}
/* look for message id in MD5s */
for (i_remote = 0; i_remote < n_remote; i_remote++)
if (md5_remote[i_remote].message_id == message_id)
break;
exist_remote = i_remote < n_remote;
for (i_cache = 0; i_cache < n_cache; i_cache++)
if (md5_cache[i_cache].message_id == message_id)
break;
exist_cache = i_cache < n_cache;
/* if message exists in both lists, compare MD5s */
if (exist_remote && exist_cache) {
/* compare MD5s */
if (get_verbose() >= VERBOSE_INFO) {
eprintf("ID%-5d: ", message_id);
for (j = 0; j < 16; j++)
eprintf("%02X", lbs->el_index[i_msg].md5_digest[j]);
eprintf("\nCache : ");
for (j = 0; j < 16; j++)
eprintf("%02X", md5_cache[i_cache].md5_digest[j]);
eprintf("\nRemote : ");
for (j = 0; j < 16; j++)
eprintf("%02X", md5_remote[i_remote].md5_digest[j]);
eprintf("\n\n");
}
/* if message has been changed on this server, but not remotely, send it */
if (!equal_md5(md5_cache[i_cache].md5_digest, lbs->el_index[i_msg].md5_digest)
&& equal_md5(md5_cache[i_cache].md5_digest, md5_remote[i_remote].md5_digest)) {
all_identical = FALSE;
if (_logging_level > 1) {
sprintf(str, "MIRROR send entry #%d", message_id);
write_logfile(lbs, str);
}
/* submit local message */
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
submit_message(lbs, list[index], message_id, error_str);
/* not that submit_message() may have changed attr_list !!! */
if (error_str[0])
sprintf(str, "%s: %s", loc("Error sending local entry"), error_str);
else
sprintf(str, "ID%d:\t%s", message_id, loc("Local entry submitted"));
mprint(lbs, mode, str);
md5_cache[i_cache].message_id = -1;
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Local entry should be submitted"));
mprint(lbs, mode, str);
}
} else
/* if message has been changed remotely, but not on this server, receive it */
if (!equal_md5(md5_cache[i_cache].md5_digest, md5_remote[i_remote].md5_digest)
&& equal_md5(md5_cache[i_cache].md5_digest, lbs->el_index[i_msg].md5_digest)) {
all_identical = FALSE;
if (mode == SYNC_CLONE) {
eprintf("ID%d:\t", message_id);
} else if (mode == SYNC_HTML) {
if (getcfg_topgroup())
rsprintf("<a href=\"../%s/%d\">ID%d:</a>\t", lbs->name_enc, message_id, message_id);
else if (sync_all)
rsprintf("<a href=\"%s/%d\">ID%d:</a>\t", lbs->name_enc, message_id, message_id);
else
rsprintf("<a href=\"%d\">ID%d:</a>\t", message_id, message_id);
flush_return_buffer();
}
if (_logging_level > 1) {
sprintf(str, "MIRROR receive entry #%d", message_id);
write_logfile(lbs, str);
}
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
receive_message(lbs, list[index], message_id, error_str, FALSE);
if (error_str[0]) {
sprintf(str, "%s: %s", loc("Error receiving message"), error_str);
mprint(lbs, mode, str);
} else if (mode == SYNC_HTML) {
rsprintf("%s\n", loc("Remote entry received"));
} else if (mode == SYNC_CLONE) {
eprintf("%s\n", loc("Remote entry received"));
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Remote entry received"));
mprint(lbs, mode, str);
}
if (!error_str[0])
md5_cache[i_cache].message_id = -1;
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Remote entry should be received"));
mprint(lbs, mode, str);
}
} else
/* if message has been changed remotely and on this server, show conflict */
if (!equal_md5(md5_cache[i_cache].md5_digest, md5_remote[i_remote].md5_digest)
&& !equal_md5(md5_cache[i_cache].md5_digest, lbs->el_index[i_msg].md5_digest)
&& !equal_md5(md5_remote[i_remote].md5_digest, lbs->el_index[i_msg].md5_digest)) {
all_identical = FALSE;
if (mode == SYNC_CLONE) {
eprintf("Warning: Entry #%d has been changed locally and remotely, will not be retrieved\n",
message_id);
} else {
if (_logging_level > 1) {
sprintf(str, "MIRROR conflict entry #%d", message_id);
write_logfile(lbs, str);
}
combine_url(lbs, list[index], "", str, sizeof(str), NULL);
if (getcfg_topgroup())
sprintf(loc_ref, "<a href=\"../%s/%d\">%s</a>", lbs->name_enc, message_id, loc("local"));
else if (sync_all)
sprintf(loc_ref, "<a href=\"%s/%d\">%s</a>", lbs->name_enc, message_id, loc("local"));
else
sprintf(loc_ref, "<a href=\"%d\">%s</a>", message_id, loc("local"));
sprintf(rem_ref, "<a href=\"http://%s%d\">%s</a>", str, message_id, loc("remote"));
sprintf(str, "ID%d:\t%s. ", message_id, loc("Entry has been changed locally and remotely"));
sprintf(str + strlen(str), loc("Please delete %s or %s entry to resolve conflict"),
loc_ref, rem_ref);
strcat(str, ".");
mprint(lbs, mode, str);
}
} else {
/* messages are identical */
md5_cache[i_cache].message_id = -1;
}
}
if (exist_cache && !exist_remote) {
/* if message has been changed locally, send it */
if (!equal_md5(md5_cache[i_cache].md5_digest, lbs->el_index[i_msg].md5_digest)) {
/* compare MD5s */
if (get_verbose() >= VERBOSE_INFO) {
eprintf("ID%-5d: ", message_id);
for (j = 0; j < 16; j++)
eprintf("%02X", lbs->el_index[i_msg].md5_digest[j]);
eprintf("\nCache : ");
for (j = 0; j < 16; j++)
eprintf("%02X", md5_cache[i_cache].md5_digest[j]);
eprintf("\nRemote : none");
eprintf("\n\n");
}
all_identical = FALSE;
if (_logging_level > 1) {
sprintf(str, "MIRROR send entry #%d", message_id);
write_logfile(lbs, str);
}
/* submit local message */
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
submit_message(lbs, list[index], message_id, error_str);
/* not that submit_message() may have changed attr_list !!! */
if (error_str[0])
sprintf(str, "%s: %s", loc("Error sending local message"), error_str);
else
sprintf(str, "ID%d:\t%s", message_id, loc("Local entry submitted"));
mprint(lbs, mode, str);
md5_cache[i_cache].message_id = -1;
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Local entry should be submitted"));
mprint(lbs, mode, str);
}
} else {
/* if message exists only in cache, but not remotely,
it must have been deleted remotely, so remove it locally */
if (!isparam("confirm") && mode == SYNC_HTML) {
combine_url(lbs, list[index], "", str, sizeof(str), NULL);
if (getcfg_topgroup())
sprintf(loc_ref, "<a href=\"../%s/%d\">%s</a>", lbs->name_enc, message_id, loc("local"));
else if (sync_all)
sprintf(loc_ref, "<a href=\"%s/%d\">%s</a>", lbs->name_enc, message_id,
loc("Local entry"));
else
sprintf(loc_ref, "<a href=\"%d\">%s</a>", message_id, loc("Local entry"));
sprintf(str, loc("%s should be deleted"), loc_ref);
rsprintf("ID%d:\t%s\n", message_id, str);
n_delete++;
}
if (!isparam("confirm") && mode == SYNC_CLONE) {
sprintf(str, "ID%d:\t%s", message_id, loc("Entry should be deleted locally"));
mprint(lbs, mode, str);
} else {
all_identical = FALSE;
if (mode == SYNC_CLONE) {
el_delete_message(lbs, message_id, TRUE, NULL, TRUE, TRUE);
sprintf(str, "ID%d:\t%s", message_id, loc("Entry deleted locally"));
mprint(lbs, mode, str);
/* message got deleted from local message list, so redo current index */
i_msg--;
} else {
if (_logging_level > 1) {
sprintf(str, "MIRROR delete local entry #%d", message_id);
write_logfile(lbs, str);
}
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
el_delete_message(lbs, message_id, TRUE, NULL, TRUE, TRUE);
sprintf(str, "ID%d:\t%s", message_id, loc("Entry deleted locally"));
mprint(lbs, mode, str);
/* message got deleted from local message list, so redo current index */
i_msg--;
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Entry should be deleted locally"));
mprint(lbs, mode, str);
}
}
/* mark message non-conflicting */
md5_cache[i_cache].message_id = -1;
}
}
}
/* if message does not exist in cache and remotely,
it must be new, so send it */
if (!exist_cache && !exist_remote) {
all_identical = FALSE;
if (_logging_level > 1) {
sprintf(str, "MIRROR send entry #%d", message_id);
write_logfile(lbs, str);
}
remote_id = 0;
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
remote_id = submit_message(lbs, list[index], message_id, error_str);
if (error_str[0])
sprintf(str, "%s: %s", loc("Error sending local entry"), error_str);
else if (remote_id != message_id)
sprintf(str, "Error: Submitting entry #%d resulted in remote entry #%d\n", message_id,
remote_id);
else
sprintf(str, "ID%d:\t%s", message_id, loc("Local entry submitted"));
mprint(lbs, mode, str);
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Local entry should be submitted"));
mprint(lbs, mode, str);
}
}
/* if message does not exist in cache but remotely,
messages were added on both sides, so resubmit local one and retrieve remote one
if messages are different */
if (!exist_cache && exist_remote && !equal_md5(md5_remote[i_remote].md5_digest,
lbs->el_index[i_msg].md5_digest)) {
/* compare MD5s */
if (get_verbose() >= VERBOSE_INFO) {
eprintf("ID%-5d: ", message_id);
for (j = 0; j < 16; j++)
eprintf("%02X", lbs->el_index[i_msg].md5_digest[j]);
eprintf("\nCache : none");
eprintf("\nRemote : ");
for (j = 0; j < 16; j++)
eprintf("%02X", md5_remote[i_remote].md5_digest[j]);
eprintf("\n\n");
}
all_identical = FALSE;
/* find max id both locally and remotely */
max_id = 1;
for (i = 0; i < *lbs->n_el_index; i++)
if (lbs->el_index[i].message_id > max_id)
max_id = lbs->el_index[i].message_id;
for (i = 0; i < n_remote; i++)
if (md5_remote[i].message_id > max_id)
max_id = md5_remote[i].message_id;
if (_logging_level > 1) {
sprintf(str, "MIRROR change entry #%d to #%d", message_id, max_id + 1);
write_logfile(lbs, str);
}
/* rearrange local message not to conflict with remote message */
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
el_move_message(lbs, message_id, max_id + 1);
sprintf(str, "ID%d:\t", message_id);
sprintf(str + strlen(str), loc("Changed local entry ID to %d"), max_id + 1);
mprint(lbs, mode, str);
/* current message has been changed, so start over */
i_msg--;
} else {
sprintf(str, "ID%d:\t", message_id);
sprintf(str + strlen(str), loc("Local entry ID should be changed to %d"), max_id + 1);
mprint(lbs, mode, str);
}
}
flush_return_buffer();
}
/* go through remote message which do not exist locally */
for (i_remote = 0; i_remote < n_remote; i_remote++)
if (md5_remote[i_remote].message_id) {
message_id = md5_remote[i_remote].message_id;
for (i_msg = 0; i_msg < *lbs->n_el_index; i_msg++)
if (message_id == lbs->el_index[i_msg].message_id)
break;
if (i_msg == *lbs->n_el_index) {
for (i_cache = 0; i_cache < n_cache; i_cache++)
if (md5_cache[i_cache].message_id == message_id)
break;
exist_cache = i_cache < n_cache;
if (!exist_cache) {
all_identical = FALSE;
if (mode == SYNC_HTML) {
if (getcfg_topgroup())
rsprintf("<a href=\"../%s/%d\">ID%d:</a>\t", lbs->name_enc, message_id, message_id);
else if (sync_all)
rsprintf("<a href=\"%s/%d\">ID%d:</a>\t", lbs->name_enc, message_id, message_id);
else
rsprintf("<a href=\"%d\">ID%d:</a>\t", message_id, message_id);
flush_return_buffer();
} else if (mode == SYNC_CLONE) {
eprintf("ID%d:\t", message_id);
}
/* if message does not exist locally and in cache, it is new, so retrieve it */
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
receive_message(lbs, list[index], message_id, error_str, TRUE);
if (error_str[0]) {
sprintf(str, "Error receiving message: %s", error_str);
mprint(lbs, mode, str);
} else if (mode == SYNC_HTML) {
rsprintf("%s\n", loc("Remote entry received"));
} else if (mode == SYNC_CLONE) {
eprintf("%s\n", loc("Remote entry received"));
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Remote entry received"));
mprint(lbs, mode, str);
}
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Remote entry should be received"));
mprint(lbs, mode, str);
}
} else {
if (!equal_md5(md5_cache[i_cache].md5_digest, md5_remote[i_remote].md5_digest)) {
/* compare MD5s */
if (get_verbose() >= VERBOSE_INFO) {
eprintf("ID-%5: none", message_id);
eprintf("\nCache : ");
for (j = 0; j < 16; j++)
eprintf("%02X", md5_cache[i_cache].md5_digest[j]);
eprintf("\nRemote : ");
for (j = 0; j < 16; j++)
eprintf("%02X", md5_remote[i_remote].md5_digest[j]);
eprintf("\n\n");
}
all_identical = FALSE;
/* if message has changed remotely, receive it */
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
receive_message(lbs, list[index], message_id, error_str, TRUE);
if (error_str[0]) {
sprintf(str, "Error receiving message: %s", error_str);
mprint(lbs, mode, str);
} else if (mode == SYNC_HTML) {
if (getcfg_topgroup())
rsprintf("<a href=\"../%s/%d\">ID%d:</a>\t", lbs->name_enc, message_id,
message_id);
else if (sync_all)
rsprintf("<a href=\"%s/%d\">ID%d:</a>\t", lbs->name_enc, message_id,
message_id);
else
rsprintf("<a href=\"%d\">ID%d:</a>\t", message_id, message_id);
rsprintf("%s\n", loc("Remote entry received"));
}
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Remote entry should be received"));
mprint(lbs, mode, str);
}
} else {
/* if message does not exist locally but in cache, delete remote message */
all_identical = FALSE;
if (!isparam("confirm") && mode == SYNC_HTML) {
combine_url(lbs, list[index], "", str, sizeof(str), NULL);
sprintf(rem_ref, "<a href=\"http://%s%d\">%s</a>", str, message_id,
loc("Remote entry"));
sprintf(str, loc("%s should be deleted"), rem_ref);
rsprintf("ID%d:\t%s\n", message_id, str);
n_delete++;
} else if (!isparam("confirm") && mode == SYNC_CLONE) {
sprintf(str, "ID%d:\t%s", message_id, loc("Entry should be deleted remotely"));
mprint(lbs, mode, str);
} else {
if (_logging_level > 1) {
sprintf(str, "MIRROR delete remote entry #%d", message_id);
write_logfile(lbs, str);
}
sprintf(str, "%d?cmd=%s&confirm=%s", message_id, loc("Delete"), loc("Yes"));
combine_url(lbs, list[index], str, url, sizeof(url), &ssl);
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0) {
retrieve_url(lbs, url, ssl, &buffer, TRUE);
if (strstr(buffer, "Location: ")) {
if (mode == SYNC_HTML)
rsprintf("ID%d:\t%s\n", message_id, loc("Entry deleted remotely"));
} else {
if (mode == SYNC_HTML && isparam("debug"))
rsputs(buffer);
mprint(lbs, mode, loc("Error deleting remote entry"));
}
md5_cache[i_cache].message_id = -1;
xfree(buffer);
} else {
sprintf(str, "ID%d:\t%s", message_id, loc("Entry should be deleted remotely"));
mprint(lbs, mode, str);
}
}
}
}
}
flush_return_buffer();
}
xfree(md5_remote);
/* save remote MD5s in file */
if (!all_identical) {
n_remote = retrieve_remote_md5(lbs, list[index], &md5_remote, error_str);
if (n_remote < 0)
rsprintf("%s\n", error_str);
/* keep conflicting messages in cache */
for (i = 0; i < n_cache; i++)
if (md5_cache[i].message_id != -1) {
if (i == 0)
memcpy(md5_remote[0].md5_digest, md5_cache[0].md5_digest, 16);
else
for (j = 0; j < n_remote; j++)
if (md5_remote[j].message_id == md5_cache[i].message_id) {
memcpy(md5_remote[j].md5_digest, md5_cache[i].md5_digest, 16);
break;
}
}
if (!getcfg(lbs->name, "Mirror simulate", str, sizeof(str)) || atoi(str) == 0)
save_md5(lbs, list[index], md5_remote, n_remote);
if (md5_remote)
xfree(md5_remote);
}
if (md5_cache)
xfree(md5_cache);
if (mode == SYNC_HTML && n_delete) {
if (getcfg_topgroup())
rsprintf("<br><b><a href=\"../%s/?cmd=Synchronize&confirm=1\">", lbs->name_enc);
else if (sync_all)
rsprintf("<br><b><a href=\"%s/?cmd=Synchronize&confirm=1\">", lbs->name_enc);
else
rsprintf("<br><b><a href=\"../%s/?cmd=Synchronize&confirm=1\">", lbs->name_enc);
if (n_delete > 1)
rsprintf(loc("Click here to delete %d entries"), n_delete);
else
rsprintf(loc("Click here to delete this entry"));
rsprintf("</a></b>\n");
}
if (mode == SYNC_HTML && all_identical)
rsprintf(loc("All entries identical"));
if (mode == SYNC_CLONE && all_identical)
mprint(lbs, mode, loc("All entries identical"));
if (mode == SYNC_HTML)
rsprintf("</pre>\n");
}
flush_return_buffer();
keep_alive = FALSE;
}
|
CWE-79
| null | 519,445 |
136524438725138171846068678522768877398
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
static void memory_error_and_abort(char *func) {
eprintf("%s: not enough memory\n", func);
exit(EXIT_FAILURE);
}
|
CWE-79
| null | 519,446 |
15995982665689882874931026917517388645
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void url_encode(char *ps, int size)
/********************************************************************\
Encode the given string in-place by adding %XX escapes
\********************************************************************/
{
unsigned char *pd, *p;
unsigned char str[NAME_LENGTH];
pd = str;
p = (unsigned char *) ps;
while (*p && pd < str + 250) {
if (strchr("%&=#?+<>", *p) || *p > 127) {
sprintf((char *) pd, "%%%02X", *p);
pd += 3;
p++;
} else if (*p == ' ') {
*pd++ = '+';
p++;
} else {
*pd++ = *p++;
}
}
*pd = '\0';
strlcpy(ps, (char *) str, size);
}
|
CWE-79
| null | 519,447 |
136077553410675493978206133132525372417
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void change_logbook_in_group(LOGBOOK *lbs, char *new_name) {
int i, j, n, flag;
char str[1000], grpname[256], grpmembers[1000];
char grplist[MAX_N_LIST][NAME_LENGTH];
/* enumerate groups */
for (i = 0;; i++) {
if (!enumcfg("global", grpname, sizeof(grpname), grpmembers, sizeof(grpmembers), i))
break;
flag = 0;
strlcpy(str, grpname, sizeof(str));
str[9] = 0;
if (strieq(str, "top group"))
flag = 2;
str[5] = 0;
if (strieq(str, "group"))
flag = 1;
if (flag) {
n = strbreak(grpmembers, grplist, MAX_N_LIST, ",", FALSE);
for (j = 0; j < n; j++) {
if (strieq(lbs->name, grplist[j])) {
/* rename or remove logbook */
change_config_line(lbs, grpname, lbs->name, new_name);
break;
}
}
}
}
}
|
CWE-79
| null | 519,448 |
68463912921560224452581616955829543369
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void show_browser(char *br) {
if (stristr(br, "opera"))
rsprintf("var browser = \"Opera\";\n");
else if (stristr(br, "konqueror"))
rsprintf("var browser = \"Konqueror\";\n");
else if (stristr(br, "Safari"))
rsprintf("var browser = \"Safari\";\n");
else if (stristr(br, "MSIE"))
rsprintf("var browser = \"MSIE\";\n");
else if (stristr(br, "Mozilla"))
rsprintf("var browser = \"Mozilla\";\n");
else
rsprintf("var browser = \"Other\";\n");
}
|
CWE-79
| null | 519,449 |
337809753936426282575432072468966542807
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void show_date_selector(int day, int month, int year, char *index) {
int i;
rsprintf("<select name=\"m%s\">\n", index);
if (isparam("nsel"))
rsprintf("<option value=\"<keep>\">- %s -\n", loc("keep original values"));
else
rsprintf("<option value=\"\">\n");
for (i = 0; i < 12; i++)
if (i + 1 == month)
rsprintf("<option selected value=\"%d\">%s\n", i + 1, month_name(i));
else
rsprintf("<option value=\"%d\">%s\n", i + 1, month_name(i));
rsprintf("</select>\n");
rsprintf("<select name=\"d%s\">", index);
rsprintf("<option value=\"\">\n");
for (i = 0; i < 31; i++)
if (i + 1 == day)
rsprintf("<option selected value=%d>%d\n", i + 1, i + 1);
else
rsprintf("<option value=%d>%d\n", i + 1, i + 1);
rsprintf("</select>\n");
rsprintf(" %s: ", loc("Year"));
if (year)
rsprintf("<input type=\"text\" size=5 maxlength=5 name=\"y%s\" value=\"%d\">", index, year);
else
rsprintf("<input type=\"text\" size=5 maxlength=5 name=\"y%s\">", index);
rsprintf("\n<script language=\"javascript\" type=\"text/javascript\">\n");
rsprintf("<!--\n");
rsprintf("function opencal(i)\n");
rsprintf("{\n");
rsprintf(" window.open(\"cal.html?i=\"+i, \"\",\n");
rsprintf(" \"top=280,left=350,width=300,height=195,dependent=yes,menubar=no,status=no,");
rsprintf("scrollbars=no,location=no,resizable=yes\");\n");
rsprintf("}\n\n");
rsprintf(" document.write(\" \");\n");
rsprintf(" document.write(\"<a href=\\\"javascript:opencal('%s')\\\">\");\n", index);
rsprintf(" document.writeln(\"<img src=\\\"cal.png\\\" align=\\\"middle\\\" border=\\\"0\\\"");
rsprintf("alt=\\\"%s\\\"></a>\");\n", loc("Pick a date"));
rsprintf("//-->\n");
rsprintf("</script> \n");
}
|
CWE-79
| null | 519,450 |
97043580720041028848829017765015384082
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void load_config_section(char *section, char **buffer, char *error) {
int fh, length;
char *p;
error[0] = 0;
*buffer = NULL;
fh = open(config_file, O_RDONLY | O_BINARY);
if (fh < 0) {
sprintf(error, "Cannot read configuration file \"%s\": %s", config_file, strerror(errno));
return;
}
length = lseek(fh, 0, SEEK_END);
lseek(fh, 0, SEEK_SET);
*buffer = xmalloc(length + 1);
read(fh, *buffer, length);
(*buffer)[length] = 0;
close(fh);
if (section == NULL)
return;
if ((p = (char *) find_section(*buffer, section)) != NULL) {
if (strchr(p, ']')) {
p = strchr(p, ']') + 1;
while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')
p++;
}
memmove(*buffer, p, length);
if ((p = (char *) find_next_section(*buffer + 1)) != NULL) {
*p = 0;
/* strip trailing newlines */
if (p) {
p--;
while (p > *buffer && (*p == '\n' || *p == '\r' || *p == ' ' || *p == '\t'))
*p-- = 0;
}
} else {
p = *buffer + strlen(*buffer) - 1;
while (p > *buffer && (*p == '\n' || *p == '\r' || *p == ' ' || *p == '\t'))
*p-- = 0;
}
}
}
|
CWE-79
| null | 519,451 |
93594390903950377327198148239927253101
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void initparam() {
memset(_param, 0, sizeof(_param));
memset(_value, 0, sizeof(_value));
_mtext[0] = 0;
_cmdline[0] = 0;
}
|
CWE-79
| null | 519,452 |
32938840311508172672459776900912902259
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void show_query(LOGBOOK *lbs, char *title, char *query_string, char *button1, char *button1_url,
char *button2, char *button2_url) {
show_standard_header(lbs, TRUE, "ELog query", title, FALSE, NULL, NULL, 0);
rsprintf("<table class=\"dlgframe\" cellspacing=0 align=center>");
rsprintf("<tr><td class=\"dlgtitle\">\n");
rsprintf("%s</td></tr>\n", title);
rsprintf("<tr><td align=center class=\"dlgform\">");
rsprintf("%s", query_string);
rsprintf("</td></tr>\n\n");
rsprintf("<tr><td align=center class=\"dlgform\">");
rsprintf("<input type=button value=\"%s\" onClick=\"window.location.href='%s';\">\n", button1,
button1_url);
rsprintf("<input type=button value=\"%s\" onClick=\"window.location.href='%s';\">\n", button2,
button2_url);
rsprintf("</td></tr>\n\n");
rsprintf("</table>\n");
show_bottom_text(lbs);
rsprintf("</body></html>\r\n");
}
|
CWE-79
| null | 519,453 |
294397880746012174451921772835609819104
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
int save_user_config(LOGBOOK *lbs, char *user, BOOL new_user) {
char file_name[256], str[1000], *pl, user_enc[256], new_pwd[80], new_pwd2[80], smtp_host[256],
email_addr[256], mail_from[256], mail_from_name[256], subject[256], mail_text[2000], str2[256],
admin_user[80], url[256], error[2000], sid[32];
int i, self_register, code, first_user;
PMXML_NODE node, subnode, npwd;
/* if we outsourced the authentication, use external username */
getcfg(lbs->name, "Authentication", str, sizeof(str));
if (stristr(str, "Webserver")) {
/* do not allow HTML in user name */
strencode2(user_enc, http_user, sizeof(user_enc));
} else {
strencode2(user_enc, user, sizeof(user_enc));
}
/* check for user name */
if (!isparam("new_user_name") || *getparam("new_user_name") == 0) {
sprintf(str, loc("Please enter \"%s\""), loc("Login name"));
show_error(str);
return 0;
}
/* check for full name */
if (!isparam("new_full_name") || *getparam("new_full_name") == 0) {
sprintf(str, loc("Please enter \"%s\""), loc("Full name"));
show_error(str);
return 0;
}
/* check for valid email address */
if (!isparam("new_user_email") || *getparam("new_user_email") == 0) {
show_error(loc("Please specify a valid email address"));
return 0;
}
strlcpy(str, getparam("new_user_email"), sizeof(str));
if (strchr(str, '@') == NULL || strchr(str, '.') == NULL) {
show_error(loc("Please specify a valid email address"));
return 0;
}
/* check for blank character in user name */
strlcpy(str, getparam("new_user_name"), sizeof(str));
if (strchr(str, ' ')) {
show_error(loc("User name may not contain blanks"));
return 0;
}
/* check for blank password if not external authentication */
if (isparam("newpwd")) {
strlcpy(str, getparam("newpwd"), sizeof(str));
if (str[0] == 0) {
show_error(loc("Empty password not allowed"));
return 0;
}
if (strchr(str, ' ')) {
show_error(loc("Password may not contain blanks"));
return 0;
}
}
/* check self register flag */
self_register = 0;
if (getcfg(lbs->name, "Self register", str, sizeof(str)))
self_register = atoi(str);
/* check if passwords match */
new_pwd[0] = 0;
if (isparam("newpwd") && isparam("newpwd2")) {
strlcpy(new_pwd, getparam("newpwd"), sizeof(new_pwd));
strlcpy(new_pwd2, getparam("newpwd2"), sizeof(new_pwd2));
if (strcmp(new_pwd, new_pwd2) != 0) {
show_error(loc("New passwords do not match, please retype"));
return 0;
}
}
/* check if first user */
first_user = !enum_user_line(lbs, 0, str, sizeof(str));
/* check if user exists */
if (new_user) {
if (get_user_line(lbs, user_enc, NULL, NULL, NULL, NULL, NULL, NULL) == 1) {
sprintf(str, "%s \"%s\" %s", loc("Login name"), user_enc, loc("exists already"));
show_error(str);
return 0;
}
}
/* if register through selection page, use first logbook with same password file */
if (lbs == NULL) {
getcfg(NULL, "password file", file_name, sizeof(file_name));
for (i = 0; lb_list[i].name[0]; i++) {
getcfg(lb_list[i].name, "password file", str, sizeof(str));
if (strieq(file_name, str))
break;
}
if (lb_list[i].name[0] == 0)
lbs = &lb_list[0];
else
lbs = &lb_list[i];
}
getcfg(lbs->name, "Password file", str, sizeof(str));
if (lbs->pwd_xml_tree == NULL)
return 0;
sprintf(str, "/list/user[name=%s]", user_enc);
node = mxml_find_node(lbs->pwd_xml_tree, str);
code = 0;
if (new_user) {
node = mxml_find_node(lbs->pwd_xml_tree, "/list");
if (!node) {
show_error(loc("Error accessing password file"));
return 0;
}
node = mxml_add_node(node, "user", NULL);
if (isparam("new_user_name")) {
strencode2(str, getparam("new_user_name"), sizeof(str));
mxml_add_node(node, "name", str);
}
#ifdef HAVE_PAM
getcfg(lbs->name, "Authentication", str, sizeof(str));
if (!stristr(str, "PAM")) {
#endif /* HAVE_PAM */
do_crypt(new_pwd, str, sizeof(str));
npwd = mxml_add_node(node, "password", str);
if (npwd)
mxml_add_attribute(npwd, "encoding", "SHA256");
#ifdef HAVE_PAM
}
#endif /* HAVE_PAM */
if (isparam("new_full_name")) {
strencode2(str, getparam("new_full_name"), sizeof(str));
mxml_add_node(node, "full_name", str);
}
mxml_add_node(node, "last_logout", "0");
mxml_add_node(node, "last_activity", "0");
if (isparam("new_user_email"))
mxml_add_node(node, "email", getparam("new_user_email"));
if (!first_user && (self_register == 3 || self_register == 4)) {
code = rand() + (rand() << 16);
sprintf(str, "%d", code);
mxml_add_node(node, "inactive", str);
} else
mxml_add_node(node, "inactive", "0");
} else {
/* replace record */
if (isparam("new_user_name")) {
strencode2(str, getparam("new_user_name"), sizeof(str));
mxml_replace_subvalue(node, "name", str);
}
if (new_pwd[0])
mxml_replace_subvalue(node, "password", new_pwd);
if (isparam("new_full_name")) {
strencode2(str, getparam("new_full_name"), sizeof(str));
mxml_replace_subvalue(node, "full_name", str);
}
if (isparam("new_user_email"))
mxml_replace_subvalue(node, "email", getparam("new_user_email"));
if (isparam("active"))
mxml_replace_subvalue(node, "inactive", "0");
else
mxml_replace_subvalue(node, "inactive", "1");
}
subnode = mxml_find_node(node, "email_notify");
if (subnode)
mxml_delete_node(subnode);
mxml_add_node(node, "email_notify", NULL);
subnode = mxml_find_node(node, "email_notify");
for (i = 0; lb_list[i].name[0]; i++) {
sprintf(str, "sub_lb%d", i);
if (isparam(str) && getparam(str) && atoi(getparam(str)))
mxml_add_node(subnode, "logbook", lb_list[i].name);
}
if (get_password_file(lbs, file_name, sizeof(file_name)))
mxml_write_tree(file_name, lbs->pwd_xml_tree);
/* if requested, send notification email to user or admin user */
if (new_user && !first_user && (self_register == 2 || self_register == 3 || self_register == 4)
&& !isparam("admin")) {
if (!getcfg("global", "SMTP host", smtp_host, sizeof(smtp_host))) {
show_error(loc("No SMTP host defined in [global] section of configuration file"));
return 0;
}
/* try to get URL from referer */
if (!getcfg("global", "URL", url, sizeof(url))) {
if (referer[0])
strcpy(url, referer);
else {
if (elog_tcp_port == 80) {
if (_ssl_flag)
sprintf(url, "https://%s/", http_host);
else
sprintf(url, "http://%s/", http_host);
} else {
if (_ssl_flag)
sprintf(url, "https://%s:%d/", http_host, elog_tcp_port);
else
sprintf(url, "http://%s:%d/", http_host, elog_tcp_port);
}
if (lbs) {
strlcat(url, lbs->name_enc, sizeof(url));
strlcat(url, "/", sizeof(url));
}
}
} else {
if (url[strlen(url) - 1] != '/')
strlcat(url, "/", sizeof(url));
if (lbs) {
strlcat(url, lbs->name_enc, sizeof(url));
strlcat(url, "/", sizeof(url));
}
}
retrieve_email_from(lbs, mail_from, mail_from_name, NULL);
/* send email to new user */
if (self_register == 4) {
if (lbs)
sprintf(subject, loc("Account activation for ELOG logbook \"%s\""), lbs->name);
else
sprintf(subject, loc("Account activation for ELOG on host \"%s\""), host_name);
if (!isparam("new_user_email")) {
show_error("A valid email address necessary for this ELOG account");
return 0;
}
strlcpy(email_addr, getparam("new_user_email"), sizeof(email_addr));
mail_text[0] = 0;
compose_email_header(lbs, subject, mail_from_name, email_addr,
NULL, mail_text, sizeof(mail_text), 1, 0, NULL, 0, 0);
sprintf(mail_text + strlen(mail_text), "\r\n%s:\r\n\r\n",
loc("Please click the URL below to activate following ELOG account"));
if (lbs)
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Logbook"), lbs->name);
else
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Host"), host_name);
if (isparam("new_user_name"))
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Login name"),
getparam("new_user_name"));
if (isparam("new_full_name"))
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Full name"),
getparam("new_full_name"));
if (isparam("new_user_email"))
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Email"),
getparam("new_user_email"));
sprintf(mail_text + strlen(mail_text), "\r\n%s:\r\n", loc("Activation URL"));
sprintf(mail_text + strlen(mail_text), "\r\nURL : %s", url);
if (isparam("new_user_name"))
sprintf(mail_text + strlen(mail_text), "?cmd=%s", loc("Activate"));
sprintf(mail_text + strlen(mail_text), "&code=%d&unm=%s\r\n", code, getparam("new_user_name"));
if (sendmail(lbs, smtp_host, mail_from, email_addr, mail_text, error, sizeof(error)) == -1) {
sprintf(str, loc("Cannot send email notification to \"%s\""), getparam("new_user_email"));
strlcat(str, " : ", sizeof(str));
strlcat(str, error, sizeof(str));
strencode2(str2, str, sizeof(str2));
show_error(str2);
return 0;
};
show_standard_header(lbs, FALSE, loc("ELOG registration"), "", FALSE, NULL, NULL, 0);
rsprintf("<table class=\"dlgframe\" cellspacing=0 align=center>");
rsprintf("<tr><td colspan=2 class=\"dlgtitle\">\n");
rsprintf(loc("An email has been sent to <%s>"), getparam("new_user_email"));
rsprintf(".<br>\n");
rsprintf(loc("Use that email to activate your account"));
rsprintf(".</td></tr></table>\n");
show_bottom_text(lbs);
rsprintf("</body></html>\n");
return 0;
}
/* send email to admin user(s) */
if (self_register == 2 || self_register == 3) {
if (getcfg(lbs->name, "Admin user", admin_user, sizeof(admin_user))) {
pl = strtok(admin_user, " ,");
while (pl) {
get_user_line(lbs, pl, NULL, NULL, email_addr, NULL, NULL, NULL);
if (email_addr[0]) {
/* compose subject */
if (self_register == 3) {
if (lbs)
sprintf(subject, loc("Registration request for ELOG logbook \"%s\""), lbs->name);
else
sprintf(subject, loc("Registration request for ELOG on host \"%s\""), host_name);
sprintf(str, loc("A new ELOG user wants to register on \"%s\""), host_name);
} else {
if (isparam("new_user_name")) {
if (lbs)
sprintf(subject, loc("User \"%s\" registered on logbook \"%s\""),
getparam("new_user_name"), lbs->name);
else
sprintf(subject, loc("User \"%s\" registered on host \"%s\""),
getparam("new_user_name"), host_name);
}
sprintf(str, loc("A new ELOG user has been registered on %s"), host_name);
}
mail_text[0] = 0;
compose_email_header(lbs, subject, mail_from_name, email_addr,
NULL, mail_text, sizeof(mail_text), 1, 0, NULL, 0, 0);
sprintf(mail_text + strlen(mail_text), "\r\n%s:\r\n\r\n", str);
if (lbs)
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Logbook"),
lbs->name);
else
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Host"),
host_name);
if (isparam("new_user_name"))
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Login name"),
getparam("new_user_name"));
if (isparam("new_full_name"))
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Full name"),
getparam("new_full_name"));
if (isparam("new_user_email"))
sprintf(mail_text + strlen(mail_text), "%s : %s\r\n", loc("Email"),
getparam("new_user_email"));
if (self_register == 3) {
sprintf(mail_text + strlen(mail_text), "\r\n%s:\r\n",
loc("Hit following URL to activate that account"));
sprintf(mail_text + strlen(mail_text), "\r\nURL : %s", url);
if (isparam("new_user_name"))
sprintf(mail_text + strlen(mail_text), "?cmd=%s&new_user_name=%s",
loc("Activate"), getparam("new_user_name"));
sprintf(mail_text + strlen(mail_text), "&code=%d&unm=%s\r\n", code, pl);
} else {
if (isparam("new_user_name"))
sprintf(mail_text + strlen(mail_text),
"\r\n%s URL : %s?cmd=Config&cfg_user=%s&unm=%s\r\n", loc("Logbook"),
url, getparam("new_user_name"), pl);
}
if (sendmail(lbs, smtp_host, mail_from, email_addr, mail_text, error, sizeof(error)) == -1) {
sprintf(str, loc("Cannot send email notification to \"%s\""),
getparam("new_user_email"));
strlcat(str, " : ", sizeof(str));
strlcat(str, error, sizeof(str));
strencode2(str2, str, sizeof(str2));
show_error(str2);
return 0;
};
}
pl = strtok(NULL, " ,");
}
} else {
show_error(loc("No admin user has been defined in configuration file"));
return 0;
}
if (self_register == 3) {
sprintf(str, "?cmd=%s", loc("Requested"));
redirect(lbs, str);
return 0;
}
}
}
/* log in user automatically */
if (new_user && (self_register == 1 || self_register == 2)) {
if (isparam("new_user_name")) {
/* get a new session ID */
sid_new(lbs, getparam("new_user_name"), (char *) inet_ntoa(rem_addr), sid);
if (lbs)
snprintf(str, sizeof(str), "../%s/", lbs->name_enc);
else
sprintf(str, ".");
if (isparam("new_user_name")) {
sprintf(str + strlen(str), "?cmd=%s&cfg_user=", loc("Config"));
strlcat(str, getparam("new_user_name"), sizeof(str));
} else if (isparam("cfg_user")) {
sprintf(str + strlen(str), "?cmd=%s&cfg_user=", loc("Config"));
strlcat(str, getparam("cfg_user"), sizeof(str));
} else if (getcfg(lbs->name, "password file", str2, sizeof(str2)))
sprintf(str + strlen(str), "?cmd=%s", loc("Config"));
setparam("redir", str);
/* set SID cookie */
set_sid_cookie(lbs, sid, getparam("new_user_name"));
return 0;
}
}
return 1;
}
|
CWE-79
| null | 519,454 |
250963281516267217287167287449218795256
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void extract_host(char *str) {
char *p, *ph, str2[256];
p = NULL;
if (strstr(str, "http://"))
p = str + 7;
else if (strstr(str, "https://"))
p = str + 8;
if (p) {
ph = p;
while (*p && *p != '/' && *p != ':')
p++;
*p = 0;
strcpy(str2, ph);
strcpy(str, str2);
}
}
|
CWE-79
| null | 519,455 |
78751140814007636232161282397090806788
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void show_http_header(LOGBOOK *lbs, BOOL expires, char *cookie) {
char str[256];
rsprintf("HTTP/1.1 200 Document follows\r\n");
rsprintf("Server: ELOG HTTP %s-%s\r\n", VERSION, git_revision());
if (getcfg("global", "charset", str, sizeof(str)))
rsprintf("Content-Type: text/html;charset=%s\r\n", str);
else
rsprintf("Content-Type: text/html;charset=%s\r\n", DEFAULT_HTTP_CHARSET);
if (cookie && cookie[0])
set_cookie(lbs, cookie, NULL, FALSE, "99999"); /* ten years by default */
if (keep_alive) {
rsprintf("Connection: Keep-Alive\r\n");
rsprintf("Keep-Alive: timeout=60, max=10\r\n");
}
if (expires) {
rsprintf("Pragma: no-cache\r\n");
rsprintf("Cache-control: private, max-age=0, no-cache, no-store\r\n");
}
rsprintf("\r\n");
}
|
CWE-79
| null | 519,456 |
150222901714283884080470873272585562789
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void eputs(const char *buf) {
char *p;
p = xmalloc(strlen(buf) + 2);
strcpy(p, buf);
strcat(p, "\n");
(*fputs_handler)(p);
xfree(p);
}
|
CWE-79
| null | 519,457 |
272145016746997152355648174142467085210
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void url_slash_encode(char *ps, int size)
/********************************************************************\
Do the same including '/' characters
\********************************************************************/
{
unsigned char *pd, *p;
unsigned char str[NAME_LENGTH];
pd = str;
p = (unsigned char *) ps;
while (*p && pd < str + 250) {
if (strchr("%&=#?+<>/", *p) || *p > 127) {
sprintf((char *) pd, "%%%02X", *p);
pd += 3;
p++;
} else if (*p == ' ') {
*pd++ = '+';
p++;
} else {
*pd++ = *p++;
}
}
*pd = '\0';
strlcpy(ps, (char *) str, size);
}
|
CWE-79
| null | 519,458 |
60827208030525324098365455328256787993
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
BOOL convert_password_encoding(LOGBOOK *lbs) {
PMXML_NODE node, pwd;
int i;
char str[256], oldpwd[256], file_name[256];
if (lbs->pwd_xml_tree == NULL)
return FALSE;
if ((node = mxml_find_node(lbs->pwd_xml_tree, "/list/user[1]/password")) == NULL)
return FALSE;
str[0] = 0;
if (mxml_get_attribute(node, "encoding") != NULL)
strlcpy(str, mxml_get_attribute(node, "encoding"), sizeof(str));
if (!strieq(str, "SHA256")) {
if ((node = mxml_find_node(lbs->pwd_xml_tree, "/list")) == NULL)
return FALSE;
printf("Converting password file for logbook \"%s\" to new encoding ... ", lbs->name);
for (i = 0; i < mxml_get_number_of_children(node); i++) {
sprintf(str, "/list/user[%d]/password", i + 1);
pwd = mxml_find_node(lbs->pwd_xml_tree, str);
if (pwd && mxml_get_value(pwd)) {
strlcpy(str, mxml_get_value(pwd), sizeof(str));
/* assume base64 encoding, might be wrong if HAVE_CRYPT was used */
base64_decode(str, oldpwd);
do_crypt(oldpwd, str, sizeof(str));
mxml_replace_node_value(pwd, str);
mxml_add_attribute(pwd, "encoding", "SHA256");
}
}
if (get_password_file(lbs, file_name, sizeof(file_name)))
mxml_write_tree(file_name, lbs->pwd_xml_tree);
printf("ok\n");
}
return TRUE;
}
|
CWE-79
| null | 519,459 |
170165350981363074547881687913123624767
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
int compose_email(LOGBOOK *lbs, char *rcpt_to, char *mail_to, int message_id,
char attrib[MAX_N_ATTR][NAME_LENGTH], char *mail_param, int old_mail,
char att_file[MAX_ATTACHMENTS][256], char *encoding, int reply_id) {
int i, n, flags, status, mail_encoding, mail_text_size, max_att_size, n_attachments, max_allowed_att_size;
char str[NAME_LENGTH + 100], mail_from[256], mail_from_name[256], *mail_text, smtp_host[256],
subject[256], error[256];
char list[MAX_PARAM][NAME_LENGTH], url[256];
char slist[MAX_N_ATTR + 10][NAME_LENGTH], svalue[MAX_N_ATTR + 10][NAME_LENGTH];
char multipart_boundary[80];
if (!getcfg("global", "SMTP host", smtp_host, sizeof(smtp_host))) {
show_error(loc("No SMTP host defined in [global] section of configuration file"));
return 0;
}
evaluate_conditions(lbs, attrib);
flags = 63;
if (getcfg(lbs->name, "Email format", str, sizeof(str)))
flags = atoi(str);
/* get initial HTML flag from message encoding */
mail_encoding = 1; // 1:text, 2:short HTML, 4:full HTML
if (encoding[0] == 'E' || encoding[0] == 'H')
mail_encoding = 4;
/* overwrite with config setting */
if (getcfg(lbs->name, "Email encoding", str, sizeof(str)))
mail_encoding = atoi(str);
max_allowed_att_size = (int) 10E6;
if (getcfg(lbs->name, "Max email attachment size", str, sizeof(str)))
max_allowed_att_size = atoi(str);
retrieve_email_from(lbs, mail_from, mail_from_name, attrib);
/* compose subject from attributes */
if (old_mail && getcfg(lbs->name, "Use Email Subject Edit", subject, sizeof(subject))) {
i = build_subst_list(lbs, slist, svalue, attrib, TRUE);
sprintf(str, "%d", message_id);
add_subst_list(slist, svalue, "message id", str, &i);
strsubst_list(subject, sizeof(subject), slist, svalue, i);
} else if (getcfg(lbs->name, "Use Email Subject", subject, sizeof(subject))) {
i = build_subst_list(lbs, slist, svalue, attrib, TRUE);
sprintf(str, "%d", message_id);
add_subst_list(slist, svalue, "message id", str, &i);
strsubst_list(subject, sizeof(subject), slist, svalue, i);
} else {
if (old_mail)
strcpy(subject, "Updated ELOG entry");
else
strcpy(subject, "New ELOG entry");
}
/* count attachments and get maximum size */
n_attachments = 0;
max_att_size = 0;
if (att_file) {
for (i = 0; att_file[i][0] && i < MAX_ATTACHMENTS; i++) {
if ((mail_encoding & 6) == 0 || !is_inline_attachment(encoding, message_id,
getparam("text"), i, att_file[i]))
n_attachments++;
}
max_att_size = max_attachment_size(lbs, message_id);
}
// if attachments too large, include only links to attachments
if (max_att_size > max_allowed_att_size && (flags & 16) > 0) {
flags &= ~(16);
flags |= 64;
}
compose_base_url(lbs, str, sizeof(str), TRUE);
sprintf(url, "%s%d", str, message_id);
mail_text_size = MAX_CONTENT_LENGTH + 1000;
mail_text = xmalloc(mail_text_size);
mail_text[0] = 0;
compose_email_header(lbs, subject, mail_from_name, mail_to, url, mail_text, mail_text_size, mail_encoding,
n_attachments, multipart_boundary, message_id, reply_id);
if (mail_encoding & 1)
format_email_text(lbs, attrib, att_file, old_mail, url, multipart_boundary, mail_text, mail_text_size);
if (mail_encoding & 2)
format_email_html(lbs, message_id, attrib, att_file, old_mail, encoding, url, multipart_boundary,
mail_text, mail_text_size);
if (mail_encoding & 4)
format_email_html2(lbs, message_id, att_file, old_mail, multipart_boundary, mail_text, mail_text_size,
flags);
if (n_attachments && (flags & 16)) {
if ((mail_encoding & 6) > 0)
/* only non-inline attachements */
format_email_attachments(lbs, message_id, 1, att_file, mail_text, mail_text_size,
multipart_boundary, FALSE);
else
/* all attachments */
format_email_attachments(lbs, message_id, 0, att_file, mail_text, mail_text_size,
multipart_boundary, FALSE);
}
if (multipart_boundary[0]) {
strlcat(mail_text, "--", mail_text_size);
strlcat(mail_text, multipart_boundary, mail_text_size);
strlcat(mail_text, "--\r\n\r\n", mail_text_size);
}
status = sendmail(lbs, smtp_host, mail_from, rcpt_to, mail_text, error, sizeof(error));
/*
{
int fh;
fh = open("mail.html", O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, 0644);
write(fh, mail_text, strlen(mail_text));
close(fh);
}
*/
if (status < 0) {
sprintf(str, loc("Error sending Email via \"%s\""), smtp_host);
if (error[0]) {
strlcat(str, ": ", sizeof(str));
strlcat(str, error, sizeof(str));
}
url_encode(str, sizeof(str));
sprintf(mail_param, "?error=%s", str);
} else if (error[0]) {
sprintf(str, loc("Error sending Email via \"%s\""), smtp_host);
strlcat(str, ": ", sizeof(str));
strlcat(str, error, sizeof(str));
url_encode(str, sizeof(str));
sprintf(mail_param, "?error=%s", str);
} else {
if (!getcfg(lbs->name, "Display email recipients", str, sizeof(str)) || atoi(str) == 1) {
if (mail_param[0] == 0)
strcpy(mail_param, "?");
else
strcat(mail_param, "&");
/* convert '"',CR,LF,TAB to ' ' */
while (strchr(mail_to, '"'))
*strchr(mail_to, '"') = ' ';
while (strchr(mail_to, '\r'))
*strchr(mail_to, '\r') = ' ';
while (strchr(mail_to, '\n'))
*strchr(mail_to, '\n') = ' ';
while (strchr(mail_to, '\t'))
*strchr(mail_to, '\t') = ' ';
n = strbreak(mail_to, list, MAX_PARAM, ",", FALSE);
if (n < 10) {
for (i = 0; i < n && i < MAX_PARAM; i++) {
strlcpy(str, list[i], sizeof(str));
url_encode(str, sizeof(str));
sprintf(mail_param + strlen(mail_param), "mail%d=%s", i, str);
if (i < n - 1)
strcat(mail_param, "&");
}
} else {
sprintf(str, "%d%%20%s", n, loc("recipients"));
sprintf(mail_param + strlen(mail_param), "mail0=%s", str);
}
}
}
xfree(mail_text);
return status;
}
|
CWE-79
| null | 519,460 |
119797761109789228127412314292439080736
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void set_location(LOGBOOK *lbs, char *rp) {
char str[NAME_LENGTH], group[NAME_LENGTH], list[NAME_LENGTH], *p, rel_path[NAME_LENGTH];
int i;
/* remove any CR/LF from path */
strlcpy(rel_path, rp, sizeof(rel_path));
if (strchr(rel_path, '\r'))
*strchr(rel_path, '\r') = 0;
if (strchr(rel_path, '\n'))
*strchr(rel_path, '\n') = 0;
if (getcfg(lbs->name, "Relative redirect", str, sizeof(str)) && atoi(str) == 1) {
if (rel_path[0])
strlcpy(str, rel_path, sizeof(str));
else
strlcpy(str, ".", sizeof(str));
rsputs("Location: ");
rsputs(str);
} else {
/* Absolute redirect */
/* if path contains http(s), go directly there */
if (strncmp(rel_path, "http://", 7) == 0) {
rsputs("Location: ");
rsputs(rel_path);
} else if (strncmp(rel_path, "https://", 8) == 0) {
rsputs("Location: ");
rsputs(rel_path);
} else {
/* check for URL options */
str[0] = 0;
if (lbs)
getcfg(lbs->name, "URL", str, sizeof(str));
else
getcfg("global", "URL", str, sizeof(str));
if (str[0] == 0) {
/* get redirection from referer and host */
if (referer[0]) {
strlcpy(str, referer, sizeof(str));
/* strip any parameter */
if (strchr(str, '?'))
*strchr(str, '?') = 0;
/* strip rightmost '/' */
if (str[strlen(str) - 1] == '/')
str[strlen(str) - 1] = 0;
/* extract last subdir */
p = str + strlen(str);
while (p > str && *p != '/')
p--;
if (*p == '/')
p++;
/* if last subdir equals any logbook name, strip it */
for (i = 0; lb_list[i].name[0]; i++)
if (stricmp(p, lb_list[i].name_enc) == 0) {
*p = 0;
break;
}
/* if last subdir equals any group, strip it */
snprintf(group, sizeof(group), "Group %s", p);
if (getcfg("global", group, list, sizeof(list)))
*p = 0;
/* if last subdir equals any top group, strip it */
snprintf(group, sizeof(group), "Top group %s", p);
if (getcfg("global", group, list, sizeof(list)))
*p = 0;
} else {
/* assemble absolute path from host name and port */
if (_ssl_flag)
snprintf(str, sizeof(str), "https://%s", http_host);
else
snprintf(str, sizeof(str), "http://%s", http_host);
if (elog_tcp_port != 80 && strchr(str, ':') == NULL)
sprintf(str + strlen(str), ":%d", elog_tcp_port);
strlcat(str, "/", sizeof(str));
}
/* add trailing '/' if not present */
if (str[strlen(str) - 1] != '/')
strlcat(str, "/", sizeof(str));
/* add top group if existing and not logbook */
if (!lbs && getcfg_topgroup()) {
strlcat(str, getcfg_topgroup(), sizeof(str));
strlcat(str, "/", sizeof(str));
}
if (strncmp(rel_path, "../", 3) == 0)
strlcat(str, rel_path + 3, sizeof(str));
else if (strcmp(rel_path, ".") == 0) {
if (lbs)
strlcat(str, lbs->name_enc, sizeof(str));
} else if (rel_path[0] == '/')
strlcat(str, rel_path + 1, sizeof(str));
else {
if (lbs) {
strlcat(str, lbs->name_enc, sizeof(str));
strlcat(str, "/", sizeof(str));
strlcat(str, rel_path, sizeof(str));
} else
strlcat(str, rel_path, sizeof(str));
}
rsputs("Location: ");
rsputs(str);
} else {
/* use redirection via URL */
/* if HTTP request comes from localhost, use localhost as
absolute link (needed if running on DSL at home) */
if (!str[0] && strstr(http_host, "localhost")) {
if (_ssl_flag)
strlcpy(str, "https://localhost", sizeof(str));
else
strlcpy(str, "http://localhost", sizeof(str));
if (elog_tcp_port != 80)
sprintf(str + strlen(str), ":%d", elog_tcp_port);
strlcat(str, "/", sizeof(str));
}
/* add trailing '/' if not present */
if (str[strlen(str) - 1] != '/')
strlcat(str, "/", sizeof(str));
/* add top group if existing and not logbook */
if (!lbs && getcfg_topgroup()) {
strlcat(str, getcfg_topgroup(), sizeof(str));
strlcat(str, "/", sizeof(str));
}
if (strncmp(rel_path, "../", 3) == 0)
strlcat(str, rel_path + 3, sizeof(str));
else if (strcmp(rel_path, ".") == 0) {
if (lbs)
strlcat(str, lbs->name_enc, sizeof(str));
} else if (rel_path[0] == '/')
strlcat(str, rel_path + 1, sizeof(str));
else {
if (lbs) {
strlcat(str, lbs->name_enc, sizeof(str));
strlcat(str, "/", sizeof(str));
strlcat(str, rel_path, sizeof(str));
} else
strlcat(str, rel_path, sizeof(str));
}
rsputs("Location: ");
rsputs(str);
}
}
}
rsprintf("\r\n\r\n<html>redir</html>\r\n");
}
|
CWE-79
| null | 519,461 |
171712885235242563579804625917931481551
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void strencode_nouml(char *text) {
int i;
for (i = 0; i < (int) strlen(text); i++) {
switch (text[i]) {
case '\n':
rsprintf("<br>\n");
break;
case '<':
rsprintf("<");
break;
case '>':
rsprintf(">");
break;
case '\"':
rsprintf(""");
break;
case ' ':
rsprintf(" ");
break;
/* the translation for the search highliting */
case '\001':
rsprintf("<");
break;
case '\002':
rsprintf(">");
break;
case '\003':
rsprintf("\"");
break;
case '\004':
rsprintf(" ");
break;
default:
rsprintf("%c", text[i]);
}
}
}
|
CWE-79
| null | 519,462 |
246636986021495584155960150904452955231
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void ricon(char *name, char *comment, char *onclick) {
rsprintf
("<img align=\"middle\" name=\"%s\" src=\"icons/elc_%s.png\" alt=\"%s\" title=\"%s\" border=\"0\"\n",
name, name, comment, comment);
rsprintf(" onclick=\"%s\"", onclick);
rsprintf(" onmousedown=\"document.images.%s.src='icons/eld_%s.png'\"\n", name, name);
rsprintf(" onmouseup=\"document.images.%s.src='icons/elc_%s.png'\"\n", name, name);
rsprintf(" onmouseover=\"this.style.cursor='pointer';\" />\n");
}
|
CWE-79
| null | 519,463 |
167767478938050055750348319841911085755
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void submit_elog_mirror(LOGBOOK *lbs) {
char str[1000], date[80], attrib_value[MAX_N_ATTR][NAME_LENGTH], attrib_name[MAX_N_ATTR][NAME_LENGTH],
in_reply_to[80], encoding[80], reply_to[MAX_REPLY_TO * 10], att_file[MAX_ATTACHMENTS][256],
name[NAME_LENGTH], value[NAME_LENGTH];
int i, message_id, n_attr;
BOOL bedit;
/* get attachments */
for (i = 0; i < MAX_ATTACHMENTS; i++) {
sprintf(str, "attachment%d", i);
strcpy(att_file[i], isparam(str) ? getparam(str) : "");
}
reply_to[0] = 0;
in_reply_to[0] = 0;
date[0] = 0;
encoding[0] = 0;
bedit = FALSE;
n_attr = 0;
message_id = 0;
/* retrieve attributes */
for (i = 0; i < MAX_PARAM; i++) {
if (enumparam(i, name, value)) {
if (strieq(name, "mirror_id"))
message_id = atoi(value);
else if (strieq(name, "entry_date"))
strlcpy(date, value, sizeof(date));
else if (strieq(name, "reply_to"))
strlcpy(reply_to, value, sizeof(reply_to));
else if (strieq(name, "in_reply_to"))
strlcpy(in_reply_to, value, sizeof(in_reply_to));
else if (strieq(name, "encoding"))
strlcpy(encoding, value, sizeof(encoding));
else if (!strieq(name, "cmd") && !strieq(name, "full_name") && !strieq(name, "user_email")
&& !strieq(name, "unm") && !strieq(name, "upwd") && !strieq(name, "wpwd") && strncmp(name,
"attachment",
10) !=
0) {
strlcpy(attrib_name[n_attr], name, NAME_LENGTH);
strlcpy(attrib_value[n_attr++], value, NAME_LENGTH);
}
} else
break;
}
if (message_id == 0 || date[0] == 0) {
show_error(loc("Invalid mirror_id or entry_date"));
return;
}
/* check if message already exists */
for (i = 0; i < *lbs->n_el_index; i++)
if (lbs->el_index[i].message_id == message_id) {
bedit = TRUE;
break;
}
message_id = el_submit(lbs, message_id, bedit, date, attrib_name, attrib_value, n_attr, getparam("text"),
in_reply_to, reply_to, encoding, att_file, FALSE, NULL, NULL);
if (message_id <= 0) {
sprintf(str, loc("New entry cannot be written to directory \"%s\""), lbs->data_dir);
strcat(str, "\n<p>");
strcat(str, loc("Please check that it exists and elogd has write access"));
show_error(str);
return;
}
sprintf(str, "%d", message_id);
redirect(lbs, str);
}
|
CWE-79
| null | 519,464 |
245584039523679625330337531176173890056
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void strencode2(char *b, const char *text, int size) {
int i;
*b = 0;
for (i = 0; i < (int) strlen(text); i++) {
switch (text[i]) {
case '\n':
if (strlen(b) + 5 >= (unsigned int) size)
return;
strcat(b, "<br>\n");
break;
case '<':
if (strlen(b) + 4 >= (unsigned int) size)
return;
strcat(b, "<");
break;
case '>':
if (strlen(b) + 4 >= (unsigned int) size)
return;
strcat(b, ">");
break;
case '\"':
if (strlen(b) + 6 >= (unsigned int) size)
return;
strcat(b, """);
break;
default:
if (strlen(b) + 1 >= (unsigned int) size)
return;
sprintf(b + strlen(b), "%c", text[i]);
}
}
}
|
CWE-79
| null | 519,465 |
226262704467401631065470924905743721468
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void strsubst(char *string, int size, char *pattern, char *subst)
/* subsitute "pattern" with "subst" in "string" */
{
char *tail, *p;
int s;
p = string;
for (p = stristr(p, pattern); p != NULL; p = stristr(p, pattern)) {
if (strlen(pattern) == strlen(subst)) {
memcpy(p, subst, strlen(subst));
} else if (strlen(pattern) > strlen(subst)) {
memcpy(p, subst, strlen(subst));
memmove(p + strlen(subst), p + strlen(pattern), strlen(p + strlen(pattern)) + 1);
} else {
tail = (char *) xmalloc(strlen(p) - strlen(pattern) + 1);
strcpy(tail, p + strlen(pattern));
s = size - (p - string);
strlcpy(p, subst, s);
strlcat(p, tail, s);
xfree(tail);
}
p += strlen(subst);
}
}
|
CWE-79
| null | 519,466 |
64898432119729230027989178088609011386
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void _MD5_transform(unsigned int state[4], unsigned char block[64]) {
unsigned int lA = state[0], lB = state[1], lC = state[2], lD = state[3];
unsigned int x[16];
_MD5_decode(x, block, 64);
/* round 1 */
FF(lA, lB, lC, lD, x[0], 7, 0xd76aa478); // 1
FF(lD, lA, lB, lC, x[1], 12, 0xe8c7b756); // 2
FF(lC, lD, lA, lB, x[2], 17, 0x242070db); // 3
FF(lB, lC, lD, lA, x[3], 22, 0xc1bdceee); // 4
FF(lA, lB, lC, lD, x[4], 7, 0xf57c0faf); // 5
FF(lD, lA, lB, lC, x[5], 12, 0x4787c62a); // 6
FF(lC, lD, lA, lB, x[6], 17, 0xa8304613); // 7
FF(lB, lC, lD, lA, x[7], 22, 0xfd469501); // 8
FF(lA, lB, lC, lD, x[8], 7, 0x698098d8); // 9
FF(lD, lA, lB, lC, x[9], 12, 0x8b44f7af); // 10
FF(lC, lD, lA, lB, x[10], 17, 0xffff5bb1); // 11
FF(lB, lC, lD, lA, x[11], 22, 0x895cd7be); // 12
FF(lA, lB, lC, lD, x[12], 7, 0x6b901122); // 13
FF(lD, lA, lB, lC, x[13], 12, 0xfd987193); // 14
FF(lC, lD, lA, lB, x[14], 17, 0xa679438e); // 15
FF(lB, lC, lD, lA, x[15], 22, 0x49b40821); // 16
/* round 2 */
GG(lA, lB, lC, lD, x[1], 5, 0xf61e2562); // 17
GG(lD, lA, lB, lC, x[6], 9, 0xc040b340); // 18
GG(lC, lD, lA, lB, x[11], 14, 0x265e5a51); // 19
GG(lB, lC, lD, lA, x[0], 20, 0xe9b6c7aa); // 20
GG(lA, lB, lC, lD, x[5], 5, 0xd62f105d); // 21
GG(lD, lA, lB, lC, x[10], 9, 0x2441453); // 22
GG(lC, lD, lA, lB, x[15], 14, 0xd8a1e681); // 23
GG(lB, lC, lD, lA, x[4], 20, 0xe7d3fbc8); // 24
GG(lA, lB, lC, lD, x[9], 5, 0x21e1cde6); // 25
GG(lD, lA, lB, lC, x[14], 9, 0xc33707d6); // 26
GG(lC, lD, lA, lB, x[3], 14, 0xf4d50d87); // 27
GG(lB, lC, lD, lA, x[8], 20, 0x455a14ed); // 28
GG(lA, lB, lC, lD, x[13], 5, 0xa9e3e905); // 29
GG(lD, lA, lB, lC, x[2], 9, 0xfcefa3f8); // 30
GG(lC, lD, lA, lB, x[7], 14, 0x676f02d9); // 31
GG(lB, lC, lD, lA, x[12], 20, 0x8d2a4c8a); // 32
/* round 3 */
HH(lA, lB, lC, lD, x[5], 4, 0xfffa3942); // 33
HH(lD, lA, lB, lC, x[8], 11, 0x8771f681); // 34
HH(lC, lD, lA, lB, x[11], 16, 0x6d9d6122); // 35
HH(lB, lC, lD, lA, x[14], 23, 0xfde5380c); // 36
HH(lA, lB, lC, lD, x[1], 4, 0xa4beea44); // 37
HH(lD, lA, lB, lC, x[4], 11, 0x4bdecfa9); // 38
HH(lC, lD, lA, lB, x[7], 16, 0xf6bb4b60); // 39
HH(lB, lC, lD, lA, x[10], 23, 0xbebfbc70); // 40
HH(lA, lB, lC, lD, x[13], 4, 0x289b7ec6); // 41
HH(lD, lA, lB, lC, x[0], 11, 0xeaa127fa); // 42
HH(lC, lD, lA, lB, x[3], 16, 0xd4ef3085); // 43
HH(lB, lC, lD, lA, x[6], 23, 0x4881d05); // 44
HH(lA, lB, lC, lD, x[9], 4, 0xd9d4d039); // 45
HH(lD, lA, lB, lC, x[12], 11, 0xe6db99e5); // 46
HH(lC, lD, lA, lB, x[15], 16, 0x1fa27cf8); // 47
HH(lB, lC, lD, lA, x[2], 23, 0xc4ac5665); // 48
/* round 4 */
II(lA, lB, lC, lD, x[0], 6, 0xf4292244); // 49
II(lD, lA, lB, lC, x[7], 10, 0x432aff97); // 50
II(lC, lD, lA, lB, x[14], 15, 0xab9423a7); // 51
II(lB, lC, lD, lA, x[5], 21, 0xfc93a039); // 52
II(lA, lB, lC, lD, x[12], 6, 0x655b59c3); // 53
II(lD, lA, lB, lC, x[3], 10, 0x8f0ccc92); // 54
II(lC, lD, lA, lB, x[10], 15, 0xffeff47d); // 55
II(lB, lC, lD, lA, x[1], 21, 0x85845dd1); // 56
II(lA, lB, lC, lD, x[8], 6, 0x6fa87e4f); // 57
II(lD, lA, lB, lC, x[15], 10, 0xfe2ce6e0); // 58
II(lC, lD, lA, lB, x[6], 15, 0xa3014314); // 59
II(lB, lC, lD, lA, x[13], 21, 0x4e0811a1); // 60
II(lA, lB, lC, lD, x[4], 6, 0xf7537e82); // 61
II(lD, lA, lB, lC, x[11], 10, 0xbd3af235); // 62
II(lC, lD, lA, lB, x[2], 15, 0x2ad7d2bb); // 63
II(lB, lC, lD, lA, x[9], 21, 0xeb86d391); // 64
state[0] += lA;
state[1] += lB;
state[2] += lC;
state[3] += lD;
/* lClear sensitive information */
memset(x, 0, sizeof(x));
}
|
CWE-79
| null | 519,467 |
178327172978223667087478190707212525375
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
int exist_file(char *file_name) {
int fh;
fh = open(file_name, O_RDONLY | O_BINARY);
if (fh > 0) {
close(fh);
return 1;
}
return 0;
}
|
CWE-79
| null | 519,468 |
168485246889649298062501565636921789305
| null | null |
other
|
elog
|
993bed4923c88593cc6b1186e0d1b9564994a25a
| 0 |
void write_logfile(LOGBOOK *lbs, const char *text) {
char file_name[MAX_PATH_LENGTH];
char str[MAX_PATH_LENGTH], unm[256];
int fh;
time_t now;
char buf[10000];
if (lbs == NULL) {
if (!getcfg("global", "logfile", str, sizeof(str)))
return;
} else if (!getcfg(lbs->name, "logfile", str, sizeof(str)))
return;
if (str[0] == DIR_SEPARATOR || str[1] == ':')
strlcpy(file_name, str, sizeof(file_name));
else {
strlcpy(file_name, logbook_dir, sizeof(file_name));
strlcat(file_name, str, sizeof(file_name));
}
fh = open(file_name, O_RDWR | O_BINARY | O_CREAT | O_APPEND, 0644);
if (fh < 0)
return;
now = time(0);
strftime(buf, sizeof(buf), "%d-%b-%Y %H:%M:%S", localtime(&now));
strcat(buf, " ");
if (isparam("unm") && rem_host[0]) {
strlcpy(unm, getparam("unm"), sizeof(unm));
if (rem_host_ip[0])
sprintf(buf + strlen(buf), "[%s@%s(%s)] ", unm, rem_host, rem_host_ip);
else
sprintf(buf + strlen(buf), "[%s@%s] ", unm, rem_host);
} else if (rem_host[0]) {
if (rem_host_ip[0])
sprintf(buf + strlen(buf), "[%s(%s)] ", rem_host, rem_host_ip);
else
sprintf(buf + strlen(buf), "[%s] ", rem_host);
} else
sprintf(buf + strlen(buf), "[%s] ", rem_host_ip);
if (lbs)
sprintf(buf + strlen(buf), "{%s} ", lbs->name);
strlcat(buf, text, sizeof(buf) - 1);
#ifdef OS_WINNT
if (strlen(buf) > 0 && buf[strlen(buf) - 1] != '\n')
strlcat(buf, "\r\n", sizeof(buf));
else if (strlen(buf) > 1 && buf[strlen(buf) - 2] != '\r')
strlcpy(buf + strlen(buf) - 2, "\r\n", sizeof(buf) - (strlen(buf) - 2));
#else
if (strlen(buf) > 1 && buf[strlen(buf) - 1] != '\n')
strlcat(buf, "\n", sizeof(buf));
#endif
write(fh, buf, strlen(buf));
close(fh);
}
|
CWE-79
| null | 519,469 |
125939124609626394763663233532825735071
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SpoolerQueueStop(SpoolerQueue *queuePtr, const Ns_Time *timeoutPtr, const char *name)
{
NS_NONNULL_ASSERT(timeoutPtr != NULL);
NS_NONNULL_ASSERT(name != NULL);
while (queuePtr != NULL) {
Ns_ReturnCode status;
Ns_MutexLock(&queuePtr->lock);
if (!queuePtr->stopped && !queuePtr->shutdown) {
Ns_Log(Debug, "%s%d: triggering shutdown", name, queuePtr->id);
queuePtr->shutdown = NS_TRUE;
SockTrigger(queuePtr->pipe[1]);
}
status = NS_OK;
while (!queuePtr->stopped && status == NS_OK) {
status = Ns_CondTimedWait(&queuePtr->cond, &queuePtr->lock, timeoutPtr);
}
if (status != NS_OK) {
Ns_Log(Warning, "%s%d: timeout waiting for shutdown", name, queuePtr->id);
} else {
/*Ns_Log(Notice, "%s%d: shutdown complete", name, queuePtr->id);*/
if (queuePtr->thread != NULL) {
Ns_ThreadJoin(&queuePtr->thread, NULL);
queuePtr->thread = NULL;
} else {
Ns_Log(Notice, "%s%d: shutdown: thread already gone", name, queuePtr->id);
}
ns_sockclose(queuePtr->pipe[0]);
ns_sockclose(queuePtr->pipe[1]);
}
Ns_MutexUnlock(&queuePtr->lock);
queuePtr = queuePtr->nextPtr;
}
}
|
CWE-787
| null | 519,489 |
52048058379798341026885677367796238581
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
PollSet(PollData *pdata, NS_SOCKET sock, short type, const Ns_Time *timeoutPtr)
{
NS_NONNULL_ASSERT(pdata != NULL);
/*
* Grow the pfds array if necessary.
*/
if (unlikely(pdata->nfds >= pdata->maxfds)) {
pdata->maxfds += 100u;
pdata->pfds = ns_realloc(pdata->pfds, pdata->maxfds * sizeof(struct pollfd));
}
/*
* Set the next pollfd struct with this socket.
*/
pdata->pfds[pdata->nfds].fd = sock;
pdata->pfds[pdata->nfds].events = type;
pdata->pfds[pdata->nfds].revents = 0;
/*
* Check for new minimum timeout.
*/
if (timeoutPtr != NULL && Ns_DiffTime(timeoutPtr, &pdata->timeout, NULL) < 0) {
pdata->timeout = *timeoutPtr;
}
return pdata->nfds++;
}
|
CWE-787
| null | 519,490 |
88152978571137557608215600371118475031
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockAccept(Driver *drvPtr, NS_SOCKET sock, Sock **sockPtrPtr, const Ns_Time *nowPtr)
{
Sock *sockPtr;
SockState sockStatus;
NS_DRIVER_ACCEPT_STATUS status;
NS_NONNULL_ASSERT(drvPtr != NULL);
sockPtr = SockNew(drvPtr);
/*
* Accept the new connection.
*/
status = DriverAccept(sockPtr, sock);
if (unlikely(status == NS_DRIVER_ACCEPT_ERROR)) {
sockStatus = SOCK_ERROR;
/*
* We reach the place frequently, especially on Linux, when we try to
* accept multiple connection in one sweep. Usually, the errno is
* EAGAIN.
*/
Ns_MutexLock(&drvPtr->lock);
sockPtr->nextPtr = drvPtr->sockPtr;
drvPtr->sockPtr = sockPtr;
Ns_MutexUnlock(&drvPtr->lock);
sockPtr = NULL;
} else {
sockPtr->acceptTime = *nowPtr;
drvPtr->queuesize++;
if (status == NS_DRIVER_ACCEPT_DATA) {
/*
* If there is already data present then read it without
* polling if we're in async mode.
*/
if ((drvPtr->opts & NS_DRIVER_ASYNC) != 0u) {
sockStatus = SockRead(sockPtr, 0, nowPtr);
if ((int)sockStatus < 0) {
Ns_Log(DriverDebug, "SockRead returned error %s",
GetSockStateName(sockStatus));
SockRelease(sockPtr, sockStatus, errno);
sockStatus = SOCK_ERROR;
sockPtr = NULL;
}
} else {
/*
* Queue this socket without reading, NsGetRequest() in the
* connection thread will perform actual reading of the
* request.
*/
sockStatus = SOCK_READY;
}
} else if (status == NS_DRIVER_ACCEPT_QUEUE) {
/*
* We need to call RequestNew() to make sure socket has request
* structure allocated, otherwise NsGetRequest() will call
* SockRead() which is not what this driver wants.
*/
if (sockPtr->reqPtr == NULL) {
RequestNew(sockPtr);
}
sockStatus = SOCK_READY;
} else {
sockStatus = SOCK_MORE;
}
}
*sockPtrPtr = sockPtr;
return sockStatus;
}
|
CWE-787
| null | 519,491 |
212027002201949943490650365945887001134
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockTimeout(Sock *sockPtr, const Ns_Time *nowPtr, const Ns_Time *timeout)
{
NS_NONNULL_ASSERT(sockPtr != NULL);
sockPtr->timeout = *nowPtr;
Ns_IncrTime(&sockPtr->timeout, timeout->sec, timeout->usec);
}
|
CWE-787
| null | 519,492 |
300118395634361946234510728376475070114
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterPerPoolRates(WriterSock *writePtr, Tcl_HashTable *pools)
{
WriterSock *curPtr;
Tcl_HashSearch search;
Tcl_HashEntry *hPtr;
NS_NONNULL_ASSERT(writePtr != NULL);
NS_NONNULL_ASSERT(pools != NULL);
/*
* First reset pool total rate. We keep the bandwidth managed pools in a
* thread-local memory. Before, we accumulate the data, we reset it.
*/
hPtr = Tcl_FirstHashEntry(pools, &search);
while (hPtr != NULL) {
ConnPoolInfo *infoPtr = (ConnPoolInfo *)Tcl_GetHashValue(hPtr);
infoPtr->currentPoolRate = 0;
hPtr = Tcl_NextHashEntry(&search);
}
/*
* Sum the actual rates per bandwidth limited pool for all active writer
* jobs.
*/
for (curPtr = writePtr; curPtr != NULL; curPtr = curPtr->nextPtr) {
/*
* Does the writer come form a badwidth limited pool?
*/
if (curPtr->poolPtr->rate.poolLimit > 0 && curPtr->currentRate > 0) {
/*
* Add the actual rate to the writer specific pool rate.
*/
ConnPoolInfo *infoPtr = WriterGetInfoPtr(curPtr, pools);
infoPtr->currentPoolRate += curPtr->currentRate;
Ns_Log(DriverDebug, "poollimit pool '%s' added rate poolLimit %d poolRate %d",
curPtr->poolPtr->pool,
curPtr->poolPtr->rate.poolLimit,
infoPtr->currentPoolRate);
}
}
/*
* Now iterate over the pools used by this thread and sum the specific
* pool rates from all writer threads.
*/
hPtr = Tcl_FirstHashEntry(pools, &search);
while (hPtr != NULL) {
ConnPool *poolPtr = (ConnPool *)Tcl_GetHashKey(pools, hPtr);
int totalPoolRate, writerThreadCount, threadDeltaRate;
ConnPoolInfo *infoPtr;
/*
* Compute the following indicators:
* - totalPoolRate: accumulated pool rates from all writer threads.
*
* - threadDeltaRate: how much of the available bandwidth can i used
* the current thread. We assume that the distribution of writers
* between all writer threads is even, so we can split the
* available rate by the number of writer threads working on this
* pool.
*
* - deltaPercentage: adjust in a single iteration just a fraction
* (e.g. 10 percent) of the potential change. This function is
* called often enough to justify delayed adjustments.
*/
infoPtr = (ConnPoolInfo *)Tcl_GetHashValue(hPtr);
totalPoolRate = NsPoolTotalRate(poolPtr,
infoPtr->threadSlot,
infoPtr->currentPoolRate,
&writerThreadCount);
/*
* If nothing is going on, allow a thread the full rate.
*/
if (infoPtr->currentPoolRate == 0) {
threadDeltaRate = (poolPtr->rate.poolLimit - totalPoolRate);
} else {
threadDeltaRate = (poolPtr->rate.poolLimit - totalPoolRate) / writerThreadCount;
}
infoPtr->deltaPercentage = threadDeltaRate / 10;
if (infoPtr->deltaPercentage < -50) {
infoPtr->deltaPercentage = -50;
}
if (totalPoolRate > 0) {
Ns_Log(Notice, "... pool '%s' thread's pool rate %d total pool rate %d limit %d "
"(#%d writer threads) -> computed rate %d (%d%%) ",
NsPoolName(poolPtr->pool),
infoPtr->currentPoolRate,
totalPoolRate,
poolPtr->rate.poolLimit,
writerThreadCount,
threadDeltaRate,
infoPtr->deltaPercentage
);
}
hPtr = Tcl_NextHashEntry(&search);
}
}
|
CWE-787
| null | 519,493 |
100002762018194343640840097139378302318
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsStartDrivers(void)
{
Driver *drvPtr;
/*
* Signal and wait for each driver to start.
*/
for (drvPtr = firstDrvPtr; drvPtr != NULL; drvPtr = drvPtr->nextPtr) {
if (drvPtr->port == 0u) {
/*
* Don't start a driver having port zero.
*/
continue;
}
Ns_ThreadCreate(DriverThread, drvPtr, 0, &drvPtr->thread);
Ns_MutexLock(&drvPtr->lock);
while ((drvPtr->flags & DRIVER_STARTED) == 0u) {
Ns_CondWait(&drvPtr->cond, &drvPtr->lock);
}
/*if ((drvPtr->flags & DRIVER_FAILED)) {
status = NS_ERROR;
}*/
Ns_MutexUnlock(&drvPtr->lock);
}
}
|
CWE-787
| null | 519,494 |
197408439794262549439217167447269497554
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsTclWriterObjCmd(ClientData clientData, Tcl_Interp *interp,
int objc, Tcl_Obj *const* objv)
{
const Ns_SubCmdSpec subcmds[] = {
{"list", WriterListObjCmd},
{"size", WriterSizeObjCmd},
{"streaming", WriterStreamingObjCmd},
{"submit", WriterSubmitObjCmd},
{"submitfile", WriterSubmitFileObjCmd},
{"submitfiles",WriterSubmitFilesObjCmd},
{NULL, NULL}
};
return Ns_SubcmdObjv(subcmds, clientData, interp, objc, objv);
}
|
CWE-787
| null | 519,495 |
210194308769664264749139036520659196551
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterListObjCmd(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
int result = TCL_OK;
NsServer *servPtr = NULL;
Ns_ObjvSpec lopts[] = {
{"-server", Ns_ObjvServer, &servPtr, NULL},
{NULL, NULL, NULL, NULL}
};
if (unlikely(Ns_ParseObjv(lopts, NULL, interp, 2, objc, objv) != NS_OK)) {
result = TCL_ERROR;
} else {
Tcl_DString ds, *dsPtr = &ds;
const Driver *drvPtr;
SpoolerQueue *queuePtr;
Tcl_DStringInit(dsPtr);
for (drvPtr = firstDrvPtr; drvPtr != NULL; drvPtr = drvPtr->nextPtr) {
const DrvWriter *wrPtr;
/*
* If server was specified, list only results from this server.
*/
if (servPtr != NULL && servPtr != drvPtr->servPtr) {
continue;
}
wrPtr = &drvPtr->writer;
queuePtr = wrPtr->firstPtr;
while (queuePtr != NULL) {
const WriterSock *wrSockPtr;
Ns_MutexLock(&queuePtr->lock);
wrSockPtr = queuePtr->curPtr;
while (wrSockPtr != NULL) {
char ipString[NS_IPADDR_SIZE];
ns_inet_ntop((struct sockaddr *)&(wrSockPtr->sockPtr->sa),
ipString,sizeof(ipString));
(void) Ns_DStringNAppend(dsPtr, "{", 1);
(void) Ns_DStringAppendTime(dsPtr, &wrSockPtr->startTime);
(void) Ns_DStringNAppend(dsPtr, " ", 1);
(void) Ns_DStringAppend(dsPtr, queuePtr->threadName);
(void) Ns_DStringNAppend(dsPtr, " ", 1);
(void) Ns_DStringAppend(dsPtr, drvPtr->threadName);
(void) Ns_DStringNAppend(dsPtr, " ", 1);
(void) Ns_DStringAppend(dsPtr, NsPoolName(wrSockPtr->poolPtr->pool));
(void) Ns_DStringNAppend(dsPtr, " ", 1);
(void) Ns_DStringAppend(dsPtr, ipString);
(void) Ns_DStringPrintf(dsPtr, " %d %" PRIdz " %" TCL_LL_MODIFIER "d %d %d ",
wrSockPtr->fd,
wrSockPtr->size,
wrSockPtr->nsent,
wrSockPtr->currentRate,
wrSockPtr->rateLimit);
(void) Ns_DStringAppendElement(dsPtr,
(wrSockPtr->clientData != NULL)
? wrSockPtr->clientData
: NS_EMPTY_STRING);
(void) Ns_DStringNAppend(dsPtr, "} ", 2);
wrSockPtr = wrSockPtr->nextPtr;
}
Ns_MutexUnlock(&queuePtr->lock);
queuePtr = queuePtr->nextPtr;
}
}
Tcl_DStringResult(interp, &ds);
}
return result;
}
|
CWE-787
| null | 519,496 |
133986641815299279700164318102620198334
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterThread(void *arg)
{
SpoolerQueue *queuePtr = (SpoolerQueue*)arg;
int err, pollTimeout;
bool stopping;
Ns_Time now;
Sock *sockPtr;
const Driver *drvPtr;
WriterSock *curPtr, *nextPtr, *writePtr;
PollData pdata;
Tcl_HashTable pools; /* used for accumulating bandwidth per pool */
Ns_ThreadSetName("-writer%d-", queuePtr->id);
queuePtr->threadName = Ns_ThreadGetName();
Tcl_InitHashTable(&pools, TCL_ONE_WORD_KEYS);
/*
* Loop forever until signaled to shut down and all
* connections are complete and gracefully closed.
*/
Ns_Log(Notice, "writer%d: accepting connections", queuePtr->id);
PollCreate(&pdata);
writePtr = NULL;
stopping = NS_FALSE;
while (!stopping) {
char charBuffer[1];
/*
* If there are any write sockets, set the bits.
*/
PollReset(&pdata);
(void)PollSet(&pdata, queuePtr->pipe[0], (short)POLLIN, NULL);
if (writePtr == NULL) {
pollTimeout = 30 * 1000;
} else {
/*
* If per-pool bandwidth management is requested, compute the base
* data for the adjustment. If there is no bandwidth management
* requested, there is no slowdow.
*/
if (NsWriterBandwidthManagement) {
WriterPerPoolRates(writePtr, &pools);
}
/*
* There are writers active. Determine on which writers we poll
* and compute the maximal poll wait time.
*/
pollTimeout = 1000;
for (curPtr = writePtr; curPtr != NULL; curPtr = curPtr->nextPtr) {
int sleepTimeMs = 0;
Ns_Log(DriverDebug, "### Writer poll collect %p size %" PRIdz
" streaming %d rateLimit %d",
(void *)curPtr, curPtr->size, curPtr->doStream, curPtr->rateLimit);
if (curPtr->rateLimit > 0
&& curPtr->nsent > 0
&& curPtr->currentRate > 0
) {
int currentMs, targetTimeMs;
/*
* Perform per-pool rate management, when
* - a poolLimit is provided,
* - we have performance data of thee pool, and
* - changes are possible (as flagged by deltaPercentage).
*/
if (NsWriterBandwidthManagement
&& curPtr->poolPtr->rate.poolLimit > 0
&& curPtr->infoPtr != NULL
&& curPtr->infoPtr->deltaPercentage != 0
) {
/*
* Only adjust data for busy writer jobs, which
* are close to their limits.
*/
bool onLimit = (curPtr->currentRate*100 / curPtr->rateLimit) > 90;
Ns_Log(DriverDebug, "we allowed %d we use %d on limit %d (%d) , we can do %d%%",
curPtr->rateLimit, curPtr->currentRate,
(int)onLimit, curPtr->currentRate*100/curPtr->rateLimit,
curPtr->infoPtr->deltaPercentage);
if (onLimit) {
/*
* Compute new rate limit based on
* positive/negative delta percentage.
*/
int newRate = curPtr->currentRate +
(curPtr->currentRate * curPtr->infoPtr->deltaPercentage / 100);
/*
* Sanity checks:
* - never allow more than poolLimit
* - never kill connections completely (e.g. minRate 5KB/s)
*/
if (newRate > curPtr->poolPtr->rate.poolLimit) {
newRate = curPtr->poolPtr->rate.poolLimit;
} else if (newRate < 5) {
newRate = 5;
}
Ns_Log(Notice, "... pool '%s' new rate limit changed from %d to %d KB/s (delta %d%%)",
curPtr->poolPtr->pool, curPtr->rateLimit, newRate,
curPtr->infoPtr->deltaPercentage);
curPtr->rateLimit = newRate;
}
}
/*
* Adjust rate to the rate limit.
*/
currentMs = (int)(curPtr->nsent/(Tcl_WideInt)curPtr->currentRate);
targetTimeMs = (int)(curPtr->nsent/(Tcl_WideInt)curPtr->rateLimit);
sleepTimeMs = 1 + targetTimeMs - currentMs;
Ns_Log(WriterDebug, "### Writer(%d)"
" byte sent %" TCL_LL_MODIFIER "d msecs %d rate %d KB/s"
" targetRate %d KB/s sleep %d",
curPtr->sockPtr->sock,
curPtr->nsent, currentMs,
curPtr->currentRate,
curPtr->rateLimit,
sleepTimeMs);
}
if (likely(curPtr->size > 0u)) {
if (sleepTimeMs <= 0) {
SockPoll(curPtr->sockPtr, (short)POLLOUT, &pdata);
pollTimeout = -1;
} else {
pollTimeout = MIN(sleepTimeMs, pollTimeout);
}
} else if (unlikely(curPtr->doStream == NS_WRITER_STREAM_FINISH)) {
pollTimeout = -1;
}
}
}
Ns_Log(DriverDebug, "### Writer final pollTimeout %d", pollTimeout);
/*
* Select and drain the trigger pipe if necessary.
*/
(void) PollWait(&pdata, pollTimeout);
if (PollIn(&pdata, 0) && unlikely(ns_recv(queuePtr->pipe[0], charBuffer, 1u, 0) != 1)) {
Ns_Fatal("writer: trigger ns_recv() failed: %s",
ns_sockstrerror(ns_sockerrno));
}
/*
* Write to all available sockets
*/
Ns_GetTime(&now);
curPtr = writePtr;
writePtr = NULL;
while (curPtr != NULL) {
NsWriterStreamState doStream;
SpoolerState spoolerState = SPOOLER_OK;
nextPtr = curPtr->nextPtr;
sockPtr = curPtr->sockPtr;
err = 0;
/*
* The truth value of doStream does not change through
* concurrency.
*/
doStream = curPtr->doStream;
if (unlikely(PollHup(&pdata, sockPtr->pidx))) {
Ns_Log(DriverDebug, "### Writer %p reached POLLHUP fd %d", (void *)curPtr, sockPtr->sock);
spoolerState = SPOOLER_CLOSE;
err = 0;
curPtr->infoPtr = WriterGetInfoPtr(curPtr, &pools);
curPtr->infoPtr->currentPoolRate += curPtr->currentRate;
} else if (likely(PollOut(&pdata, sockPtr->pidx)) || (doStream == NS_WRITER_STREAM_FINISH)) {
/*
* The socket is writable, we can compute the rate, when
* something was sent already and some kind of rate limiting
* is in place ... and we have sent enough data to make a good
* estimate (just after the 2nd send, so more than driver
* buffer size.
*/
Ns_Log(DriverDebug, "Socket of pool '%s' is writable, writer limit %d nsent %ld",
curPtr->poolPtr->pool, curPtr->rateLimit, (long)curPtr->nsent);
if (curPtr->rateLimit > 0
&& (size_t)curPtr->nsent > curPtr->sockPtr->drvPtr->bufsize
) {
Ns_Time diff;
long currentMs;
Ns_DiffTime(&now, &curPtr->startTime, &diff);
currentMs = Ns_TimeToMilliseconds(&diff);
if (currentMs > 0) {
curPtr->currentRate = (int)((curPtr->nsent)/(Tcl_WideInt)currentMs);
Ns_Log(DriverDebug,
"Socket of pool '%s' is writable, currentMs %ld has updated current rate %d",
curPtr->poolPtr->pool, currentMs,curPtr->currentRate);
}
}
Ns_Log(DriverDebug,
"### Writer %p can write to client fd %d (trigger %d) streaming %.6x"
" size %" PRIdz " nsent %" TCL_LL_MODIFIER "d bufsize %" PRIdz,
(void *)curPtr, sockPtr->sock, PollIn(&pdata, 0), doStream,
curPtr->size, curPtr->nsent, curPtr->c.file.bufsize);
if (unlikely(curPtr->size < 1u)) {
/*
* Size < 1 means that everything was sent.
*/
if (doStream != NS_WRITER_STREAM_ACTIVE) {
if (doStream == NS_WRITER_STREAM_FINISH) {
Ns_ReleaseTemp(curPtr->fd);
}
spoolerState = SPOOLER_CLOSE;
}
} else {
/*
* If size > 0, there is still something to send.
* If we are spooling from a file, read some data
* from the (spool) file and place it into curPtr->c.file.buf.
*/
if (curPtr->fd != NS_INVALID_FD) {
spoolerState = WriterReadFromSpool(curPtr);
}
if (spoolerState == SPOOLER_OK) {
spoolerState = WriterSend(curPtr, &err);
}
}
} else {
/*
* Mark when first timeout occurred or check if it is already
* for too long and we need to stop this socket
*/
if (sockPtr->timeout.sec == 0) {
Ns_Log(DriverDebug, "Writer %p fd %d setting sendwait %ld.%6ld",
(void *)curPtr, sockPtr->sock,
curPtr->sockPtr->drvPtr->sendwait.sec,
curPtr->sockPtr->drvPtr->sendwait.usec);
SockTimeout(sockPtr, &now, &curPtr->sockPtr->drvPtr->sendwait);
} else if (Ns_DiffTime(&sockPtr->timeout, &now, NULL) <= 0) {
Ns_Log(DriverDebug, "Writer %p fd %d timeout", (void *)curPtr, sockPtr->sock);
err = ETIMEDOUT;
spoolerState = SPOOLER_CLOSETIMEOUT;
}
}
/*
* Check result status and close the socket in case of
* timeout or completion
*/
Ns_MutexLock(&queuePtr->lock);
if (spoolerState == SPOOLER_OK) {
if (curPtr->size > 0u || doStream == NS_WRITER_STREAM_ACTIVE) {
Ns_Log(DriverDebug,
"Writer %p continue OK (size %" PRIdz ") => PUSH",
(void *)curPtr, curPtr->size);
Push(curPtr, writePtr);
} else {
Ns_Log(DriverDebug,
"Writer %p done OK (size %" PRIdz ") => RELEASE",
(void *)curPtr, curPtr->size);
WriterSockRelease(curPtr);
}
} else {
/*
* spoolerState might be SPOOLER_CLOSE or SPOOLER_*TIMEOUT, or SPOOLER_*ERROR
*/
Ns_Log(DriverDebug,
"Writer %p fd %d release, not OK (status %d) => RELEASE",
(void *)curPtr, curPtr->sockPtr->sock, (int)spoolerState);
curPtr->status = spoolerState;
curPtr->err = err;
WriterSockRelease(curPtr);
}
Ns_MutexUnlock(&queuePtr->lock);
curPtr = nextPtr;
}
/*
* Add more sockets to the writer queue
*/
if (queuePtr->sockPtr != NULL) {
Ns_MutexLock(&queuePtr->lock);
if (queuePtr->sockPtr != NULL) {
curPtr = queuePtr->sockPtr;
queuePtr->sockPtr = NULL;
while (curPtr != NULL) {
nextPtr = curPtr->nextPtr;
sockPtr = curPtr->sockPtr;
drvPtr = sockPtr->drvPtr;
SockTimeout(sockPtr, &now, &drvPtr->sendwait);
Push(curPtr, writePtr);
queuePtr->queuesize++;
curPtr = nextPtr;
}
queuePtr->curPtr = writePtr;
}
Ns_MutexUnlock(&queuePtr->lock);
}
/*
* Check for shutdown
*/
stopping = queuePtr->shutdown;
}
PollFree(&pdata);
{
/*
* Free ConnPoolInfo
*/
Tcl_HashSearch search;
Tcl_HashEntry *hPtr = Tcl_FirstHashEntry(&pools, &search);
while (hPtr != NULL) {
ConnPoolInfo *infoPtr = (ConnPoolInfo *)Tcl_GetHashValue(hPtr);
ns_free(infoPtr);
hPtr = Tcl_NextHashEntry(&search);
}
/*
* Delete the hash table for pools.
*/
Tcl_DeleteHashTable(&pools);
}
Ns_Log(Notice, "exiting");
Ns_MutexLock(&queuePtr->lock);
queuePtr->stopped = NS_TRUE;
Ns_CondBroadcast(&queuePtr->cond);
Ns_MutexUnlock(&queuePtr->lock);
}
|
CWE-787
| null | 519,497 |
135325495921509563770675923077632887044
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsWriterFinish(NsWriterSock *wrSockPtr) {
WriterSock *writerSockPtr = (WriterSock *)wrSockPtr;
NS_NONNULL_ASSERT(wrSockPtr != NULL);
Ns_Log(DriverDebug, "NsWriterFinish: %p", (void *)writerSockPtr);
writerSockPtr->doStream = NS_WRITER_STREAM_FINISH;
SockTrigger(writerSockPtr->queuePtr->pipe[1]);
}
|
CWE-787
| null | 519,498 |
327483444522865625953785061318046789070
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
DriverThread(void *arg)
{
Driver *drvPtr = (Driver*)arg;
Ns_Time now, diff;
char charBuffer[1], drain[1024];
int pollTimeout, accepted, nrBindaddrs = 0;
bool stopping;
unsigned int flags;
Sock *sockPtr, *closePtr, *nextPtr, *waitPtr, *readPtr;
PollData pdata;
Ns_ThreadSetName("-driver:%s-", drvPtr->threadName);
Ns_Log(Notice, "starting");
flags = DRIVER_STARTED;
{
Tcl_Obj *bindaddrsObj, **objv;
int j = 0, result;
bindaddrsObj = Tcl_NewStringObj(drvPtr->address, -1);
Tcl_IncrRefCount(bindaddrsObj);
result = Tcl_ListObjGetElements(NULL, bindaddrsObj, &nrBindaddrs, &objv);
/*
* "result" was ok during startup, it has still to be ok.
*/
assert(result == TCL_OK);
if (result == TCL_OK) {
int i;
/*
* Bind all provided addresses.
*/
for (i = 0; i < nrBindaddrs; i++) {
drvPtr->listenfd[j] = DriverListen(drvPtr, Tcl_GetString(objv[i]));
if (drvPtr->listenfd[j] != NS_INVALID_SOCKET) {
j ++;
}
}
if (j > 0 && j < nrBindaddrs) {
Ns_Log(Warning, "could only bind to %d out of %d addresses", j, nrBindaddrs);
}
}
/*
* "j" refers to the number of successful listen() operations.
*/
nrBindaddrs = j;
Tcl_DecrRefCount(bindaddrsObj);
}
if (nrBindaddrs > 0) {
SpoolerQueueStart(drvPtr->spooler.firstPtr, SpoolerThread);
SpoolerQueueStart(drvPtr->writer.firstPtr, WriterThread);
} else {
Ns_Log(Warning, "could no bind any of the following addresses, stopping this driver: %s", drvPtr->address);
flags |= (DRIVER_FAILED | DRIVER_SHUTDOWN);
}
Ns_MutexLock(&drvPtr->lock);
drvPtr->flags |= flags;
Ns_CondBroadcast(&drvPtr->cond);
Ns_MutexUnlock(&drvPtr->lock);
/*
* Loop forever until signaled to shut down and all
* connections are complete and gracefully closed.
*/
PollCreate(&pdata);
Ns_GetTime(&now);
closePtr = waitPtr = readPtr = NULL;
stopping = ((flags & DRIVER_SHUTDOWN) != 0u);
if (!stopping) {
Ns_Log(Notice, "driver: accepting connections");
}
while (!stopping) {
int n;
/*
* Set the bits for all active drivers if a connection
* isn't already pending.
*/
PollReset(&pdata);
(void)PollSet(&pdata, drvPtr->trigger[0], (short)POLLIN, NULL);
if (likely(waitPtr == NULL)) {
for (n = 0; n < nrBindaddrs; n++) {
drvPtr->pidx[n] = PollSet(&pdata, drvPtr->listenfd[n],
(short)POLLIN, NULL);
}
}
/*
* If there are any closing or read-ahead sockets, set the bits
* and determine the minimum relative timeout.
*
* TODO: the various poll timeouts should probably be configurable.
*/
if (readPtr == NULL && closePtr == NULL) {
pollTimeout = 10 * 1000;
} else {
for (sockPtr = readPtr; sockPtr != NULL; sockPtr = sockPtr->nextPtr) {
SockPoll(sockPtr, (short)POLLIN, &pdata);
}
for (sockPtr = closePtr; sockPtr != NULL; sockPtr = sockPtr->nextPtr) {
SockPoll(sockPtr, (short)POLLIN, &pdata);
}
if (Ns_DiffTime(&pdata.timeout, &now, &diff) > 0) {
/*
* The resolution of "pollTimeout" is ms, therefore, we round
* up. If we would round down (e.g. 500 microseconds to 0 ms),
* the time comparison later would determine that it is too
* early.
*/
pollTimeout = (int)Ns_TimeToMilliseconds(&diff) + 1;
} else {
pollTimeout = 0;
}
}
n = PollWait(&pdata, pollTimeout);
Ns_Log(DriverDebug, "=== PollWait returned %d, trigger[0] %d", n, PollIn(&pdata, 0));
if (PollIn(&pdata, 0) && unlikely(ns_recv(drvPtr->trigger[0], charBuffer, 1u, 0) != 1)) {
const char *errstr = ns_sockstrerror(ns_sockerrno);
Ns_Fatal("driver: trigger ns_recv() failed: %s", errstr);
}
/*
* Check whether we should re-animate some connection threads,
* when e.g. the number of current threads dropped below the
* minimal value. Perform this test on timeouts (n == 0;
* just for safety reasons) or on explicit wakeup calls.
*/
if ((n == 0) || PollIn(&pdata, 0)) {
NsServer *servPtr = drvPtr->servPtr;
if (servPtr != NULL) {
/*
* Check if we have to reanimate the current server.
*/
NsEnsureRunningConnectionThreads(servPtr, NULL);
} else {
Ns_Set *servers = Ns_ConfigCreateSection("ns/servers");
size_t j;
/*
* Reanimation check on all servers.
*/
for (j = 0u; j < Ns_SetSize(servers); ++j) {
const char *server = Ns_SetKey(servers, j);
servPtr = NsGetServer(server);
if (servPtr != NULL) {
NsEnsureRunningConnectionThreads(servPtr, NULL);
}
}
}
}
/*
* Update the current time and drain and/or release any
* closing sockets.
*/
Ns_GetTime(&now);
if (closePtr != NULL) {
sockPtr = closePtr;
closePtr = NULL;
while (sockPtr != NULL) {
nextPtr = sockPtr->nextPtr;
if (unlikely(PollHup(&pdata, sockPtr->pidx))) {
/*
* Peer has closed the connection
*/
SockRelease(sockPtr, SOCK_CLOSE, 0);
} else if (likely(PollIn(&pdata, sockPtr->pidx))) {
/*
* Got some data
*/
ssize_t received = ns_recv(sockPtr->sock, drain, sizeof(drain), 0);
if (received <= 0) {
Ns_Log(DriverDebug, "poll closewait pollin; sockrelease SOCK_READERROR (sock %d)",
sockPtr->sock);
SockRelease(sockPtr, SOCK_READERROR, 0);
} else {
Push(sockPtr, closePtr);
}
} else if (Ns_DiffTime(&sockPtr->timeout, &now, &diff) <= 0) {
/* no PollHup, no PollIn, maybe timeout */
Ns_Log(DriverDebug, "poll closewait timeout; sockrelease SOCK_CLOSETIMEOUT (sock %d)",
sockPtr->sock);
SockRelease(sockPtr, SOCK_CLOSETIMEOUT, 0);
} else {
/* too early, keep waiting */
Push(sockPtr, closePtr);
}
sockPtr = nextPtr;
}
}
/*
* Attempt read-ahead of any new connections.
*/
sockPtr = readPtr;
readPtr = NULL;
while (likely(sockPtr != NULL)) {
nextPtr = sockPtr->nextPtr;
if (unlikely(PollHup(&pdata, sockPtr->pidx))) {
/*
* Peer has closed the connection
*/
SockRelease(sockPtr, SOCK_CLOSE, 0);
} else if (unlikely(!PollIn(&pdata, sockPtr->pidx))
&& ((sockPtr->reqPtr == NULL) || (sockPtr->reqPtr->leftover == 0u))) {
/*
* Got no data for this sockPtr.
*/
if (Ns_DiffTime(&sockPtr->timeout, &now, &diff) <= 0) {
SockRelease(sockPtr, SOCK_READTIMEOUT, 0);
} else {
Push(sockPtr, readPtr);
}
} else {
/*
* Got some data for this sockPtr.
* If enabled, perform read-ahead now.
*/
assert(drvPtr == sockPtr->drvPtr);
if (likely((drvPtr->opts & NS_DRIVER_ASYNC) != 0u)) {
SockState s = SockRead(sockPtr, 0, &now);
/*
* Queue for connection processing if ready.
*/
switch (s) {
case SOCK_SPOOL:
drvPtr->stats.spooled++;
if (SockSpoolerQueue(drvPtr, sockPtr) == 0) {
Push(sockPtr, readPtr);
}
break;
case SOCK_MORE:
drvPtr->stats.partial++;
SockTimeout(sockPtr, &now, &drvPtr->recvwait);
Push(sockPtr, readPtr);
break;
case SOCK_READY:
if (SockQueue(sockPtr, &now) == NS_TIMEOUT) {
Push(sockPtr, waitPtr);
}
break;
/*
* Already handled or normal cases
*/
case SOCK_ENTITYTOOLARGE: NS_FALL_THROUGH; /* fall through */
case SOCK_BADREQUEST: NS_FALL_THROUGH; /* fall through */
case SOCK_BADHEADER: NS_FALL_THROUGH; /* fall through */
case SOCK_TOOMANYHEADERS: NS_FALL_THROUGH; /* fall through */
case SOCK_CLOSE:
SockRelease(sockPtr, s, errno);
break;
/*
* Exceptions
*/
case SOCK_READERROR: NS_FALL_THROUGH; /* fall through */
case SOCK_CLOSETIMEOUT: NS_FALL_THROUGH; /* fall through */
case SOCK_ERROR: NS_FALL_THROUGH; /* fall through */
case SOCK_READTIMEOUT: NS_FALL_THROUGH; /* fall through */
case SOCK_SHUTERROR: NS_FALL_THROUGH; /* fall through */
case SOCK_WRITEERROR: NS_FALL_THROUGH; /* fall through */
case SOCK_WRITETIMEOUT:
drvPtr->stats.errors++;
Ns_Log(Warning,
"sockread returned unexpected result %s (err %s); close socket (%d)",
GetSockStateName(s),
((errno != 0) ? strerror(errno) : NS_EMPTY_STRING),
sockPtr->sock);
SockRelease(sockPtr, s, errno);
break;
}
} else {
/*
* Potentially blocking driver, NS_DRIVER_ASYNC is not defined
*/
if (Ns_DiffTime(&sockPtr->timeout, &now, &diff) <= 0) {
drvPtr->stats.errors++;
Ns_Log(Notice, "read-ahead has some data, no async sock read ===== diff time %ld",
Ns_DiffTime(&sockPtr->timeout, &now, &diff));
sockPtr->keep = NS_FALSE;
SockRelease(sockPtr, SOCK_READTIMEOUT, 0);
} else {
if (SockQueue(sockPtr, &now) == NS_TIMEOUT) {
Push(sockPtr, waitPtr);
}
}
}
}
sockPtr = nextPtr;
}
/*
* Attempt to queue any pending connection after reversing the
* list to ensure oldest connections are tried first.
*/
if (waitPtr != NULL) {
sockPtr = NULL;
while ((nextPtr = waitPtr) != NULL) {
waitPtr = nextPtr->nextPtr;
Push(nextPtr, sockPtr);
}
while (sockPtr != NULL) {
nextPtr = sockPtr->nextPtr;
if (SockQueue(sockPtr, &now) == NS_TIMEOUT) {
Push(sockPtr, waitPtr);
}
sockPtr = nextPtr;
}
}
/*
* If no connections are waiting, attempt to accept more.
*/
if (waitPtr == NULL) {
/*
* If configured, try to accept more than one request, under heavy load
* this helps to process more requests
*/
SockState s;
bool acceptMore = NS_TRUE;
accepted = 0;
while (acceptMore &&
accepted < drvPtr->acceptsize
&& drvPtr->queuesize < drvPtr->maxqueuesize ) {
bool gotRequests = NS_FALSE;
/*
* Check for input data on all bind addresses. Stop checking,
* when one round of checking on all addresses fails.
*/
for (n = 0; n < nrBindaddrs; n++) {
if (
PollIn(&pdata, drvPtr->pidx[n])
&& (s = SockAccept(drvPtr, pdata.pfds[drvPtr->pidx[n]].fd, &sockPtr, &now)) != SOCK_ERROR) {
switch (s) {
case SOCK_SPOOL:
drvPtr->stats.spooled++;
if (SockSpoolerQueue(drvPtr, sockPtr) == 0) {
Push(sockPtr, readPtr);
}
break;
case SOCK_MORE:
drvPtr->stats.partial++;
SockTimeout(sockPtr, &now, &drvPtr->recvwait);
Push(sockPtr, readPtr);
break;
case SOCK_READY:
if (SockQueue(sockPtr, &now) == NS_TIMEOUT) {
Push(sockPtr, waitPtr);
}
break;
case SOCK_BADHEADER: NS_FALL_THROUGH; /* fall through */
case SOCK_BADREQUEST: NS_FALL_THROUGH; /* fall through */
case SOCK_CLOSE: NS_FALL_THROUGH; /* fall through */
case SOCK_CLOSETIMEOUT: NS_FALL_THROUGH; /* fall through */
case SOCK_ENTITYTOOLARGE: NS_FALL_THROUGH; /* fall through */
case SOCK_ERROR: NS_FALL_THROUGH; /* fall through */
case SOCK_READERROR: NS_FALL_THROUGH; /* fall through */
case SOCK_READTIMEOUT: NS_FALL_THROUGH; /* fall through */
case SOCK_SHUTERROR: NS_FALL_THROUGH; /* fall through */
case SOCK_TOOMANYHEADERS: NS_FALL_THROUGH; /* fall through */
case SOCK_WRITEERROR: NS_FALL_THROUGH; /* fall through */
case SOCK_WRITETIMEOUT:
Ns_Fatal("driver: SockAccept returned: %s", GetSockStateName(s));
}
accepted++;
gotRequests = NS_TRUE;
#ifdef __APPLE__
/*
* On Darwin, the first accept() succeeds typically, but it is
* useless to try, since this leads always to an EAGAIN
*/
acceptMore = NS_FALSE;
break;
#endif
}
}
if (!gotRequests) {
acceptMore = NS_FALSE;
}
}
if (accepted > 1) {
Ns_Log(Notice, "... sockAccept accepted %d connections", accepted);
}
}
/*
* Check for shut down and get the list of any closing or
* keep-alive sockets.
*/
Ns_MutexLock(&drvPtr->lock);
sockPtr = drvPtr->closePtr;
drvPtr->closePtr = NULL;
flags = drvPtr->flags;
Ns_MutexUnlock(&drvPtr->lock);
stopping = ((flags & DRIVER_SHUTDOWN) != 0u);
/*
* Update the timeout for each closing socket and add to the
* close list if some data has been read from the socket
* (i.e., it's not a closing keep-alive connection).
*/
while (sockPtr != NULL) {
nextPtr = sockPtr->nextPtr;
if (sockPtr->keep) {
assert(drvPtr == sockPtr->drvPtr);
Ns_Log(DriverDebug, "setting keepwait %ld.%6ld for socket %d",
drvPtr->keepwait.sec, drvPtr->keepwait.usec,
sockPtr->sock);
SockTimeout(sockPtr, &now, &drvPtr->keepwait);
Push(sockPtr, readPtr);
} else {
/*
* Purely packet oriented drivers set on close the fd to
* NS_INVALID_SOCKET. Since we cannot "shutdown" an UDP-socket
* for writing, we bypass this call.
*/
assert(drvPtr == sockPtr->drvPtr);
if (sockPtr->sock == NS_INVALID_SOCKET) {
SockRelease(sockPtr, SOCK_CLOSE, errno);
Ns_Log(DriverDebug, "DRIVER SockRelease: errno %d drvPtr->closewait %ld.%6ld",
errno, drvPtr->closewait.sec, drvPtr->closewait.usec);
} else if (shutdown(sockPtr->sock, SHUT_WR) != 0) {
SockRelease(sockPtr, SOCK_SHUTERROR, errno);
} else {
Ns_Log(DriverDebug, "setting closewait %ld.%6ld for socket %d",
drvPtr->closewait.sec, drvPtr->closewait.usec, sockPtr->sock);
SockTimeout(sockPtr, &now, &drvPtr->closewait);
Push(sockPtr, closePtr);
}
}
sockPtr = nextPtr;
}
/*
* Close the active drivers if shutdown is pending.
*/
if (stopping) {
for (n = 0; n < nrBindaddrs; n++) {
ns_sockclose(drvPtr->listenfd[n]);
drvPtr->listenfd[n] = NS_INVALID_SOCKET;
}
}
}
PollFree(&pdata);
Ns_Log(Notice, "exiting");
Ns_MutexLock(&drvPtr->lock);
drvPtr->flags |= DRIVER_STOPPED;
Ns_CondBroadcast(&drvPtr->cond);
Ns_MutexUnlock(&drvPtr->lock);
}
|
CWE-787
| null | 519,499 |
276235058269981880892989406631316404403
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SpoolerQueueStart(SpoolerQueue *queuePtr, Ns_ThreadProc *proc)
{
NS_NONNULL_ASSERT(proc != NULL);
while (queuePtr != NULL) {
if (ns_sockpair(queuePtr->pipe) != 0) {
Ns_Fatal("ns_sockpair() failed: %s", ns_sockstrerror(ns_sockerrno));
}
Ns_ThreadCreate(proc, queuePtr, 0, &queuePtr->thread);
queuePtr = queuePtr->nextPtr;
}
}
|
CWE-787
| null | 519,500 |
290991076863196034721972362766557426150
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockSendResponse(Sock *sockPtr, int code, const char *errMsg)
{
struct iovec iov[3];
char header[32];
ssize_t sent, tosend;
NS_NONNULL_ASSERT(sockPtr != NULL);
NS_NONNULL_ASSERT(errMsg != NULL);
snprintf(header, sizeof(header), "HTTP/1.0 %d ", code);
iov[0].iov_base = header;
iov[0].iov_len = strlen(header);
iov[1].iov_base = (void *)errMsg;
iov[1].iov_len = strlen(errMsg);
iov[2].iov_base = (void *)"\r\n\r\n";
iov[2].iov_len = 4u;
tosend = (ssize_t)(iov[0].iov_len + iov[1].iov_len + iov[2].iov_len);
sent = NsDriverSend(sockPtr, iov, 3, 0u);
if (sent < tosend) {
Ns_Log(Warning, "Driver: partial write while sending response;"
" %" PRIdz " < %" PRIdz, sent, tosend);
}
/*
* In case we have a request structure, complain the system log about
* the bad request.
*/
if (sockPtr->reqPtr != NULL) {
Request *reqPtr = sockPtr->reqPtr;
const char *requestLine = (reqPtr->request.line != NULL) ? reqPtr->request.line : NS_EMPTY_STRING;
(void)ns_inet_ntop((struct sockaddr *)&(sockPtr->sa), sockPtr->reqPtr->peer, NS_IPADDR_SIZE);
/*
* Check, if bad request looks like a TLS handshake. If yes, there is
* no need to print out the received buffer.
*/
if (requestLine[0] == (char)0x16 && requestLine[1] >= 3 && requestLine[2] == 1) {
Ns_Log(Warning, "invalid request %d (%s) from peer %s: received TLS handshake on a non-TLS connection",
code, errMsg, reqPtr->peer);
} else {
Tcl_DString dsReqLine;
Tcl_DStringInit(&dsReqLine);
Ns_Log(Warning, "invalid request: %d (%s) from peer %s request '%s' offsets: read %" PRIuz
" write %" PRIuz " content %" PRIuz " avail %" PRIuz,
code, errMsg,
reqPtr->peer,
Ns_DStringAppendPrintable(&dsReqLine, NS_FALSE, requestLine, strlen(requestLine)),
reqPtr->roff,
reqPtr->woff,
reqPtr->coff,
reqPtr->avail);
Tcl_DStringFree(&dsReqLine);
LogBuffer(Warning, "REQ BUFFER", reqPtr->buffer.string, (size_t)reqPtr->buffer.length);
}
} else {
Ns_Log(Warning, "invalid request: %d (%s) - no request information available",
code, errMsg);
}
}
|
CWE-787
| null | 519,501 |
48130110115913429720739497505751926455
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
AsyncLogfileCloseObjCmd(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
int fd, result = TCL_OK;
Ns_ObjvValueRange range = {0, INT_MAX};
Ns_ObjvSpec args[] = {
{"fd", Ns_ObjvInt, &fd, &range},
{NULL, NULL, NULL, NULL}
};
if (unlikely(Ns_ParseObjv(NULL, args, interp, 2, objc, objv) != NS_OK)) {
result = TCL_ERROR;
} else {
int rc = ns_close(fd);
if (rc != 0) {
Ns_TclPrintfResult(interp, "could not close fd %d: %s",
fd, Tcl_PosixError(interp));
result = TCL_ERROR;
}
}
return result;
}
|
CWE-787
| null | 519,502 |
82339701004971716346329983090088830651
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
ChunkedDecode(Request *reqPtr, bool update)
{
const Tcl_DString *bufPtr;
const char *end, *chunkStart;
SockState result = SOCK_READY;
NS_NONNULL_ASSERT(reqPtr != NULL);
bufPtr = &reqPtr->buffer;
end = bufPtr->string + bufPtr->length;
chunkStart = bufPtr->string + reqPtr->chunkStartOff;
while (reqPtr->chunkStartOff < (size_t)bufPtr->length) {
char *p = strstr(chunkStart, "\r\n");
long chunkLength;
if (p == NULL) {
Ns_Log(DriverDebug, "ChunkedDecode: chunk did not find end-of-line");
result = SOCK_MORE;
break;
}
*p = '\0';
chunkLength = strtol(chunkStart, NULL, 16);
*p = '\r';
if (chunkLength < 0) {
Ns_Log(Warning, "ChunkedDecode: negative chunk length");
result = SOCK_BADREQUEST;
break;
}
*p = '\r';
if (p + 2 + chunkLength > end) {
Ns_Log(DriverDebug, "ChunkedDecode: chunk length past end of buffer");
result = SOCK_MORE;
break;
}
if (update) {
char *writeBuffer = bufPtr->string + reqPtr->chunkWriteOff;
memmove(writeBuffer, p + 2, (size_t)chunkLength);
reqPtr->chunkWriteOff += (size_t)chunkLength;
*(writeBuffer + chunkLength) = '\0';
}
reqPtr->chunkStartOff += (size_t)(p - chunkStart) + 4u + (size_t)chunkLength;
chunkStart = bufPtr->string + reqPtr->chunkStartOff;
}
return result;
}
|
CWE-787
| null | 519,503 |
46377551344842501013718525564349347367
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockNew(Driver *drvPtr)
{
Sock *sockPtr;
NS_NONNULL_ASSERT(drvPtr != NULL);
Ns_MutexLock(&drvPtr->lock);
sockPtr = drvPtr->sockPtr;
if (likely(sockPtr != NULL)) {
drvPtr->sockPtr = sockPtr->nextPtr;
sockPtr->keep = NS_FALSE;
}
Ns_MutexUnlock(&drvPtr->lock);
if (sockPtr == NULL) {
size_t sockSize = sizeof(Sock) + (nsconf.nextSlsId * sizeof(Ns_Callback *));
sockPtr = ns_calloc(1u, sockSize);
sockPtr->drvPtr = drvPtr;
} else {
sockPtr->tfd = 0;
sockPtr->taddr = NULL;
sockPtr->flags = 0u;
sockPtr->arg = NULL;
sockPtr->recvSockState = NS_SOCK_NONE;
}
return sockPtr;
}
|
CWE-787
| null | 519,504 |
15092322681009539718294740166315396061
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockRelease(Sock *sockPtr, SockState reason, int err)
{
Driver *drvPtr;
NS_NONNULL_ASSERT(sockPtr != NULL);
Ns_Log(DriverDebug, "SockRelease reason %s err %d (sock %d)",
GetSockStateName(reason), err, sockPtr->sock);
drvPtr = sockPtr->drvPtr;
assert(drvPtr != NULL);
SockError(sockPtr, reason, err);
if (sockPtr->sock != NS_INVALID_SOCKET) {
SockClose(sockPtr, (int)NS_FALSE);
} else {
Ns_Log(DriverDebug, "SockRelease bypasses SockClose, since we have an invalid socket");
}
NsSlsCleanup(sockPtr);
drvPtr->queuesize--;
if (sockPtr->reqPtr != NULL) {
Ns_Log(DriverDebug, "SockRelease calls RequestFree");
RequestFree(sockPtr);
}
Ns_MutexLock(&drvPtr->lock);
sockPtr->nextPtr = drvPtr->sockPtr;
drvPtr->sockPtr = sockPtr;
Ns_MutexUnlock(&drvPtr->lock);
}
|
CWE-787
| null | 519,505 |
273348023538466971923991356658895726335
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterGetMemunitFromDict(Tcl_Interp *interp, Tcl_Obj *dictObj, Tcl_Obj *keyObj, Ns_ObjvValueRange *rangePtr,
Tcl_WideInt *valuePtr)
{
Tcl_Obj *intObj = NULL;
int result;
NS_NONNULL_ASSERT(interp != NULL);
NS_NONNULL_ASSERT(dictObj != NULL);
NS_NONNULL_ASSERT(keyObj != NULL);
NS_NONNULL_ASSERT(valuePtr != NULL);
result = Tcl_DictObjGet(interp, dictObj, keyObj, &intObj);
if (result == TCL_OK && intObj != NULL) {
result = Ns_TclGetMemUnitFromObj(interp, intObj, valuePtr);
if (result == TCL_OK && rangePtr != NULL) {
result = Ns_CheckWideRange(interp, Tcl_GetString(keyObj), rangePtr, *valuePtr);
}
}
return result;
}
|
CWE-787
| null | 519,506 |
166792749691889320719366355566551649554
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsStopSpoolers(void)
{
const Driver *drvPtr;
Ns_Log(Notice, "driver: stopping writer and spooler threads");
/*
* Shutdown all spooler and writer threads
*/
for (drvPtr = firstDrvPtr; drvPtr != NULL; drvPtr = drvPtr->nextPtr) {
Ns_Time timeout;
if ((drvPtr->flags & DRIVER_STARTED) == 0u) {
continue;
}
Ns_GetTime(&timeout);
Ns_IncrTime(&timeout, nsconf.shutdowntimeout.sec, nsconf.shutdowntimeout.usec);
SpoolerQueueStop(drvPtr->writer.firstPtr, &timeout, "writer");
SpoolerQueueStop(drvPtr->spooler.firstPtr, &timeout, "spooler");
}
}
|
CWE-787
| null | 519,507 |
128877334325308472022046075900950530069
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
ServerMapEntryAdd(Tcl_DString *dsPtr, const char *host,
NsServer *servPtr, Driver *drvPtr, bool addDefaultMapEntry) {
Tcl_HashEntry *hPtr;
int isNew;
NS_NONNULL_ASSERT(dsPtr != NULL);
NS_NONNULL_ASSERT(host != NULL);
NS_NONNULL_ASSERT(servPtr != NULL);
NS_NONNULL_ASSERT(drvPtr != NULL);
hPtr = Tcl_CreateHashEntry(&drvPtr->hosts, host, &isNew);
if (isNew != 0) {
ServerMap *mapPtr;
(void) Ns_DStringVarAppend(dsPtr, drvPtr->protocol, "://", host, (char *)0L);
mapPtr = ns_malloc(sizeof(ServerMap) + (size_t)dsPtr->length);
mapPtr->servPtr = servPtr;
memcpy(mapPtr->location, dsPtr->string, (size_t)dsPtr->length + 1u);
Tcl_SetHashValue(hPtr, mapPtr);
Ns_Log(Notice, "%s: adding virtual host entry for host <%s> location: %s mapped to server: %s",
drvPtr->threadName, host, mapPtr->location, servPtr->server);
if (addDefaultMapEntry) {
drvPtr->defMapPtr = mapPtr;
}
/*
* Always reset the Tcl_DString
*/
Ns_DStringSetLength(dsPtr, 0);
} else {
Ns_Log(Notice, "%s: ignore duplicate virtual host entry: %s",
drvPtr->threadName, host);
}
}
|
CWE-787
| null | 519,508 |
127051945773436470323736774983948167629
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NSDriverClientOpen(Tcl_Interp *interp, const char *driverName,
const char *url, const char *httpMethod, const char *version,
const Ns_Time *timeoutPtr, Sock **sockPtrPtr)
{
char *protocol, *host, *portString, *path, *tail, *url2;
int result = TCL_OK;
NS_NONNULL_ASSERT(interp != NULL);
NS_NONNULL_ASSERT(url != NULL);
NS_NONNULL_ASSERT(httpMethod != NULL);
NS_NONNULL_ASSERT(version != NULL);
NS_NONNULL_ASSERT(sockPtrPtr != NULL);
url2 = ns_strdup(url);
/*
* We need here a fully qualified URL, otherwise raise an error
*/
if (unlikely(Ns_ParseUrl(url2, &protocol, &host, &portString, &path, &tail) != NS_OK)
|| protocol == NULL || host == NULL || path == NULL || tail == NULL) {
Ns_Log(Notice, "driver: invalid URL '%s' passed to NSDriverClientOpen", url2);
result = TCL_ERROR;
} else {
Driver *drvPtr;
unsigned short portNr = 0u; /* make static checker happy */
assert(protocol != NULL);
assert(host != NULL);
assert(path != NULL);
assert(tail != NULL);
/*
* Find a matching driver for the specified protocol and optionally
* the specified driver name.
*/
drvPtr = LookupDriver(interp, protocol, driverName);
if (drvPtr == NULL) {
result = TCL_ERROR;
} else if (portString != NULL) {
portNr = (unsigned short) strtol(portString, NULL, 10);
} else if (drvPtr->defport != 0u) {
/*
* Get the default port from the driver structure;
*/
portNr = drvPtr->defport;
} else {
Ns_TclPrintfResult(interp, "no default port for protocol '%s' defined", protocol);
result = TCL_ERROR;
}
if (result == TCL_OK) {
NS_SOCKET sock;
Ns_ReturnCode status;
sock = Ns_SockTimedConnect2(host, portNr, NULL, 0u, timeoutPtr, &status);
if (sock == NS_INVALID_SOCKET) {
Ns_SockConnectError(interp, host, portNr, status);
result = TCL_ERROR;
} else {
const char *query;
Tcl_DString ds, *dsPtr = &ds;
Request *reqPtr;
Sock *sockPtr;
assert(drvPtr != NULL);
sockPtr = SockNew(drvPtr);
sockPtr->sock = sock;
sockPtr->servPtr = drvPtr->servPtr;
if (sockPtr->servPtr == NULL) {
const NsInterp *itPtr = NsGetInterpData(interp);
sockPtr->servPtr = itPtr->servPtr;
}
RequestNew(sockPtr);
Ns_GetTime(&sockPtr->acceptTime);
reqPtr = sockPtr->reqPtr;
Tcl_DStringInit(dsPtr);
Ns_DStringAppend(dsPtr, httpMethod);
Ns_StrToUpper(Ns_DStringValue(dsPtr));
Tcl_DStringAppend(dsPtr, " /", 2);
if (*path != '\0') {
if (*path == '/') {
path ++;
}
Tcl_DStringAppend(dsPtr, path, -1);
Tcl_DStringAppend(dsPtr, "/", 1);
}
Tcl_DStringAppend(dsPtr, tail, -1);
Tcl_DStringAppend(dsPtr, " HTTP/", 6);
Tcl_DStringAppend(dsPtr, version, -1);
reqPtr->request.line = Ns_DStringExport(dsPtr);
reqPtr->request.method = ns_strdup(httpMethod);
reqPtr->request.protocol = ns_strdup(protocol);
reqPtr->request.host = ns_strdup(host);
query = strchr(tail, INTCHAR('?'));
if (query != NULL) {
reqPtr->request.query = ns_strdup(query+1);
} else {
reqPtr->request.query = NULL;
}
/*Ns_Log(Notice, "REQUEST LINE <%s> query <%s>", reqPtr->request.line, reqPtr->request.query);*/
*sockPtrPtr = sockPtr;
}
}
}
ns_free(url2);
return result;
}
|
CWE-787
| null | 519,509 |
213736266570053167312416231822358885022
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
DriverInit(const char *server, const char *moduleName, const char *threadName,
const Ns_DriverInitData *init,
NsServer *servPtr, const char *path,
const char *bindaddrs, const char *defserver, const char *host)
{
const char *defproto;
Driver *drvPtr;
DrvWriter *wrPtr;
DrvSpooler *spPtr;
int i;
unsigned short defport;
NS_NONNULL_ASSERT(threadName != NULL);
NS_NONNULL_ASSERT(init != NULL);
NS_NONNULL_ASSERT(path != NULL);
NS_NONNULL_ASSERT(bindaddrs != NULL);
NS_NONNULL_ASSERT(host != NULL);
/*
* Set the protocol and port defaults.
*/
if (init->protocol != NULL) {
defproto = init->protocol;
defport = init->defaultPort;
} else {
defproto = "unknown";
defport = 0u;
}
Ns_Log(DriverDebug, "DriverInit server <%s> threadName %s proto %s port %hu",
server, threadName, defproto, defport);
/*
* Allocate a new driver instance and set configurable parameters.
*/
drvPtr = ns_calloc(1u, sizeof(Driver));
Ns_MutexInit(&drvPtr->lock);
Ns_MutexSetName2(&drvPtr->lock, "ns:drv", threadName);
Ns_MutexInit(&drvPtr->spooler.lock);
Ns_MutexSetName2(&drvPtr->spooler.lock, "ns:drv:spool", threadName);
Ns_MutexInit(&drvPtr->writer.lock);
Ns_MutexSetName2(&drvPtr->writer.lock, "ns:drv:writer", threadName);
if (ns_sockpair(drvPtr->trigger) != 0) {
Ns_Fatal("ns_sockpair() failed: %s", ns_sockstrerror(ns_sockerrno));
}
drvPtr->server = server;
drvPtr->type = init->name;
drvPtr->moduleName = ns_strdup(moduleName);
drvPtr->threadName = ns_strdup(threadName);
drvPtr->defserver = defserver;
drvPtr->listenProc = init->listenProc;
drvPtr->acceptProc = init->acceptProc;
drvPtr->recvProc = init->recvProc;
drvPtr->sendProc = init->sendProc;
drvPtr->sendFileProc = init->sendFileProc;
drvPtr->keepProc = init->keepProc;
drvPtr->requestProc = init->requestProc;
drvPtr->closeProc = init->closeProc;
drvPtr->clientInitProc = init->clientInitProc;
drvPtr->arg = init->arg;
drvPtr->opts = init->opts;
drvPtr->servPtr = servPtr;
drvPtr->defport = defport;
drvPtr->bufsize = (size_t)Ns_ConfigMemUnitRange(path, "bufsize", 16384, 1024, INT_MAX);
drvPtr->maxinput = Ns_ConfigMemUnitRange(path, "maxinput", 1024*1024, 1024, LLONG_MAX);
drvPtr->maxupload = Ns_ConfigMemUnitRange(path, "maxupload", 0, 0, (Tcl_WideInt)drvPtr->maxinput);
drvPtr->readahead = Ns_ConfigMemUnitRange(path, "readahead", (Tcl_WideInt)drvPtr->bufsize,
(Tcl_WideInt)drvPtr->bufsize, drvPtr->maxinput);
drvPtr->maxline = Ns_ConfigIntRange(path, "maxline", 8192, 256, INT_MAX);
drvPtr->maxheaders = Ns_ConfigIntRange(path, "maxheaders", 128, 8, INT_MAX);
drvPtr->maxqueuesize = Ns_ConfigIntRange(path, "maxqueuesize", 1024, 1, INT_MAX);
Ns_ConfigTimeUnitRange(path, "sendwait",
"30s", 1, 0, INT_MAX, 0, &drvPtr->sendwait);
Ns_ConfigTimeUnitRange(path, "recvwait",
"30s", 1, 0, INT_MAX, 0, &drvPtr->recvwait);
Ns_ConfigTimeUnitRange(path, "closewait",
"2s", 0, 0, INT_MAX, 0, &drvPtr->closewait);
Ns_ConfigTimeUnitRange(path, "keepwait",
"5s", 0, 0, INT_MAX, 0, &drvPtr->keepwait);
drvPtr->backlog = Ns_ConfigIntRange(path, "backlog", 256, 1, INT_MAX);
drvPtr->driverthreads = Ns_ConfigIntRange(path, "driverthreads", 1, 1, 32);
drvPtr->reuseport = Ns_ConfigBool(path, "reuseport", NS_FALSE);
drvPtr->acceptsize = Ns_ConfigIntRange(path, "acceptsize", drvPtr->backlog, 1, INT_MAX);
drvPtr->keepmaxuploadsize = (size_t)Ns_ConfigMemUnitRange(path, "keepalivemaxuploadsize",
0, 0, INT_MAX);
drvPtr->keepmaxdownloadsize = (size_t)Ns_ConfigMemUnitRange(path, "keepalivemaxdownloadsize",
0, 0, INT_MAX);
drvPtr->recvTimeout = drvPtr->recvwait;
Tcl_InitHashTable(&drvPtr->hosts, TCL_STRING_KEYS);
if (drvPtr->driverthreads > 1) {
#if !defined(SO_REUSEPORT)
drvPtr->driverthreads = 1;
drvPtr->reuseport = NS_FALSE;
#else
/*
* When driver threads > 1, "reuseport" has to be active.
*/
drvPtr->reuseport = NS_TRUE;
#endif
}
if (drvPtr->reuseport) {
/*
* Reuseport was specified
*/
#if !defined(SO_REUSEPORT)
Ns_Log(Warning,
"parameter %s reuseport was specified, but is not supported by the operating system",
path);
drvPtr->reuseport = NS_FALSE;
#endif
}
drvPtr->uploadpath = ns_strdup(Ns_ConfigString(path, "uploadpath", nsconf.tmpDir));
/*
* If activated, "maxupload" has to be at least "readahead" bytes. Tell
* the user in case the config values are overruled.
*/
if ((drvPtr->maxupload > 0) &&
(drvPtr->maxupload < drvPtr->readahead)) {
Ns_Log(Warning,
"parameter %s maxupload % " TCL_LL_MODIFIER
"d invalid; can be either 0 or must be >= %" TCL_LL_MODIFIER
"d (size of readahead)",
path, drvPtr->maxupload, drvPtr->readahead);
drvPtr->maxupload = drvPtr->readahead;
}
/*
* Determine the port and then set the HTTP location string either
* as specified in the config file or constructed from the
* protocol, hostname and port.
*/
drvPtr->protocol = ns_strdup(defproto);
drvPtr->address = ns_strdup(bindaddrs);
drvPtr->port = (unsigned short)Ns_ConfigIntRange(path, "port", (int)defport, 0, 65535);
drvPtr->location = Ns_ConfigGetValue(path, "location");
if (drvPtr->location != NULL && (strstr(drvPtr->location, "://") != NULL)) {
drvPtr->location = ns_strdup(drvPtr->location);
} else {
Tcl_DString ds, *dsPtr = &ds;
Ns_DStringInit(dsPtr);
Ns_HttpLocationString(dsPtr, drvPtr->protocol, host, drvPtr->port, defport);
drvPtr->location = Ns_DStringExport(dsPtr);
}
drvPtr->nextPtr = firstDrvPtr;
firstDrvPtr = drvPtr;
/*
* Add driver specific extra headers.
*/
drvPtr->extraHeaders = Ns_ConfigSet(path, "extraheaders");
/*
* Check if upload spooler are enabled
*/
spPtr = &drvPtr->spooler;
spPtr->threads = Ns_ConfigIntRange(path, "spoolerthreads", 0, 0, 32);
if (spPtr->threads > 0) {
Ns_Log(Notice, "%s: enable %d spooler thread(s) "
"for uploads >= %" TCL_LL_MODIFIER "d bytes", threadName,
spPtr->threads, drvPtr->readahead);
for (i = 0; i < spPtr->threads; i++) {
SpoolerQueue *queuePtr = ns_calloc(1u, sizeof(SpoolerQueue));
char buffer[100];
snprintf(buffer, sizeof(buffer), "ns:driver:spooler:%d", i);
Ns_MutexSetName2(&queuePtr->lock, buffer, "queue");
queuePtr->id = i;
Push(queuePtr, spPtr->firstPtr);
}
} else {
Ns_Log(Notice, "%s: enable %d spooler thread(s) ",
threadName, spPtr->threads);
}
/*
* Enable writer threads
*/
wrPtr = &drvPtr->writer;
wrPtr->threads = Ns_ConfigIntRange(path, "writerthreads", 0, 0, 32);
if (wrPtr->threads > 0) {
wrPtr->writersize = (size_t)Ns_ConfigMemUnitRange(path, "writersize",
1024*1024, 1024, INT_MAX);
wrPtr->bufsize = (size_t)Ns_ConfigMemUnitRange(path, "writerbufsize",
8192, 512, INT_MAX);
wrPtr->rateLimit = Ns_ConfigIntRange(path, "writerratelimit", 0, 0, INT_MAX);
wrPtr->doStream = Ns_ConfigBool(path, "writerstreaming", NS_FALSE)
? NS_WRITER_STREAM_ACTIVE : NS_WRITER_STREAM_NONE;
Ns_Log(Notice, "%s: enable %d writer thread(s) "
"for downloads >= %" PRIdz " bytes, bufsize=%" PRIdz " bytes, HTML streaming %d",
threadName, wrPtr->threads, wrPtr->writersize, wrPtr->bufsize, wrPtr->doStream);
for (i = 0; i < wrPtr->threads; i++) {
SpoolerQueue *queuePtr = ns_calloc(1u, sizeof(SpoolerQueue));
char buffer[100];
snprintf(buffer, sizeof(buffer), "ns:driver:writer:%d", i);
Ns_MutexSetName2(&queuePtr->lock, buffer, "queue");
queuePtr->id = i;
Push(queuePtr, wrPtr->firstPtr);
}
} else {
Ns_Log(Notice, "%s: enable %d writer thread(s) ",
threadName, wrPtr->threads);
}
return NS_OK;
}
|
CWE-787
| null | 519,510 |
80718623656792444672140501788876247443
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsTclDriverObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
const Ns_SubCmdSpec subcmds[] = {
{"info", DriverInfoObjCmd},
{"names", DriverNamesObjCmd},
{"threads", DriverThreadsObjCmd},
{"stats", DriverStatsObjCmd},
{NULL, NULL}
};
return Ns_SubcmdObjv(subcmds, clientData, interp, objc, objv);
}
|
CWE-787
| null | 519,511 |
253439467843580612354265446290664598626
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
RequestFree(Sock *sockPtr)
{
Request *reqPtr;
bool keep;
NS_NONNULL_ASSERT(sockPtr != NULL);
reqPtr = sockPtr->reqPtr;
assert(reqPtr != NULL);
Ns_Log(DriverDebug, "=== RequestFree cleans %p (avail %" PRIuz " keep %d length %" PRIuz " contentLength %" PRIuz ")",
(void *)reqPtr, reqPtr->avail, sockPtr->keep, reqPtr->length, reqPtr->contentLength);
keep = (sockPtr->keep) && (reqPtr->avail > reqPtr->contentLength);
if (keep) {
size_t leftover = reqPtr->avail - reqPtr->contentLength;
const char *offset = reqPtr->buffer.string + ((size_t)reqPtr->buffer.length - leftover);
Ns_Log(DriverDebug, "setting leftover to %" PRIuz " bytes", leftover);
/*
* Here it is safe to move the data in the buffer, although the
* reqPtr->content might point to it, since we re-init the content. In
* case the terminating null character was written to the end of the
* previous buffer, we have to restore the first character.
*/
memmove(reqPtr->buffer.string, offset, leftover);
if (reqPtr->savedChar != '\0') {
reqPtr->buffer.string[0] = reqPtr->savedChar;
}
Tcl_DStringSetLength(&reqPtr->buffer, (int)leftover);
LogBuffer(DriverDebug, "KEEP BUFFER", reqPtr->buffer.string, leftover);
reqPtr->leftover = leftover;
} else {
/*
* Clean large buffers in order to avoid memory growth on huge
* uploads (when maxupload is huge)
*/
/*fprintf(stderr, "=== reuse buffer size %d avail %d dynamic %d\n",
reqPtr->buffer.length, reqPtr->buffer.spaceAvl,
reqPtr->buffer.string == reqPtr->buffer.staticSpace);*/
if (Tcl_DStringLength(&reqPtr->buffer) > 65536) {
Tcl_DStringFree(&reqPtr->buffer);
} else {
/*
* Reuse buffer, but set length to 0.
*/
Tcl_DStringSetLength(&reqPtr->buffer, 0);
}
reqPtr->leftover = 0u;
}
reqPtr->next = NULL;
reqPtr->content = NULL;
reqPtr->length = 0u;
reqPtr->contentLength = 0u;
reqPtr->expectedLength = 0u;
reqPtr->chunkStartOff = 0u;
reqPtr->chunkWriteOff = 0u;
reqPtr->roff = 0u;
reqPtr->woff = 0u;
reqPtr->coff = 0u;
reqPtr->avail = 0u;
reqPtr->savedChar = '\0';
Ns_SetTrunc(reqPtr->headers, 0u);
if (reqPtr->auth != NULL) {
Ns_SetFree(reqPtr->auth);
reqPtr->auth = NULL;
}
if (reqPtr->request.line != NULL) {
Ns_Log(DriverDebug, "RequestFree calls Ns_ResetRequest on %p", (void*)&reqPtr->request);
Ns_ResetRequest(&reqPtr->request);
} else {
Ns_Log(DriverDebug, "RequestFree does not call Ns_ResetRequest on %p", (void*)&reqPtr->request);
}
if (!keep) {
/*
* Push the reqPtr to the pool for reuse in other connections.
*/
sockPtr->reqPtr = NULL;
Ns_MutexLock(&reqLock);
reqPtr->nextPtr = firstReqPtr;
firstReqPtr = reqPtr;
Ns_MutexUnlock(&reqLock);
} else {
/*
* Keep the partly cleaned up reqPtr associated with the connection.
*/
Ns_Log(DriverDebug, "=== KEEP request structure in sockPtr (don't push into the pool)");
}
}
|
CWE-787
| null | 519,512 |
37813452773633172319840860100569601559
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterReadFromSpool(WriterSock *curPtr) {
NsWriterStreamState doStream;
SpoolerState status = SPOOLER_OK;
size_t maxsize, toRead;
unsigned char *bufPtr;
NS_NONNULL_ASSERT(curPtr != NULL);
doStream = curPtr->doStream;
if (doStream != NS_WRITER_STREAM_NONE) {
Ns_MutexLock(&curPtr->c.file.fdlock);
toRead = curPtr->c.file.toRead;
Ns_MutexUnlock(&curPtr->c.file.fdlock);
} else {
toRead = curPtr->c.file.toRead;
Ns_Log(DriverDebug, "### WriterReadFromSpool [%d]: fd %d tosend %lu files %d",
curPtr->c.file.currentbuf, curPtr->fd, toRead, curPtr->c.file.nbufs);
}
maxsize = curPtr->c.file.maxsize;
bufPtr = curPtr->c.file.buf;
/*
* When bufsize > 0 we have a leftover from previous send. In such
* cases, move the leftover to the front, and fill the reminder of
* the buffer with new data from curPtr->c.
*/
if (curPtr->c.file.bufsize > 0u) {
Ns_Log(DriverDebug,
"### WriterReadFromSpool %p %.6x leftover %" PRIdz " offset %ld",
(void *)curPtr,
curPtr->flags,
curPtr->c.file.bufsize,
(long)curPtr->c.file.bufoffset);
if (likely(curPtr->c.file.bufoffset > 0)) {
memmove(curPtr->c.file.buf,
curPtr->c.file.buf + curPtr->c.file.bufoffset,
curPtr->c.file.bufsize);
}
bufPtr = curPtr->c.file.buf + curPtr->c.file.bufsize;
maxsize -= curPtr->c.file.bufsize;
}
if (toRead > maxsize) {
toRead = maxsize;
}
/*
* Read content from the file into the buffer.
*/
if (toRead > 0u) {
ssize_t n;
if (doStream != NS_WRITER_STREAM_NONE) {
/*
* In streaming mode, the connection thread writes to the
* spool file and the writer thread reads from the same
* file. Therefore, we have to re-adjust the current
* read/writer position, which might be changed by the
* other thread. These positions have to be locked, since
* seeking might be subject to race conditions. Here we
* set the read pointer to the position after the last
* send operation.
*/
Ns_MutexLock(&curPtr->c.file.fdlock);
(void) ns_lseek(curPtr->fd, (off_t)curPtr->nsent, SEEK_SET);
}
if (curPtr->c.file.nbufs == 0) {
/*
* Working on a single fd.
*/
n = ns_read(curPtr->fd, bufPtr, toRead);
} else {
/*
* Working on a Ns_FileVec.
*/
int currentbuf = curPtr->c.file.currentbuf;
size_t wantRead = curPtr->c.file.bufs[currentbuf].length;
size_t segSize = (wantRead > toRead ? toRead : wantRead);
n = ns_read(curPtr->fd, bufPtr, segSize);
Ns_Log(DriverDebug, "### WriterReadFromSpool [%d] (nbufs %d): read from fd %d want %lu got %ld (remain %lu)",
currentbuf, curPtr->c.file.nbufs, curPtr->fd, segSize, n, wantRead);
if (n > 0) {
/*
* Reduce the remaining length in the Ns_FileVec for the
* next iteration.
*/
curPtr->c.file.bufs[currentbuf].length -= (size_t)n;
if ((size_t)n < wantRead) {
/*
* Partial read on a segment.
*/
Ns_Log(DriverDebug, "### WriterReadFromSpool [%d] (nbufs %d): partial read on fd %d (got %ld)",
currentbuf, curPtr->c.file.nbufs,
curPtr->fd, n);
} else if (currentbuf < curPtr->c.file.nbufs - 1 /* && (n == wantRead) */) {
/*
* All read from this segment, setup next read.
*/
ns_close(curPtr->fd);
curPtr->c.file.bufs[currentbuf].fd = NS_INVALID_FD;
curPtr->c.file.currentbuf ++;
curPtr->fd = curPtr->c.file.bufs[curPtr->c.file.currentbuf].fd;
Ns_Log(DriverDebug, "### WriterReadFromSpool switch to [%d] fd %d",
curPtr->c.file.currentbuf, curPtr->fd);
}
}
}
if (n <= 0) {
status = SPOOLER_READERROR;
} else {
/*
* curPtr->c.file.toRead is still protected by
* curPtr->c.file.fdlock when needed (in streaming mode).
*/
curPtr->c.file.toRead -= (size_t)n;
curPtr->c.file.bufsize += (size_t)n;
}
if (doStream != NS_WRITER_STREAM_NONE) {
Ns_MutexUnlock(&curPtr->c.file.fdlock);
}
}
return status;
}
|
CWE-787
| null | 519,513 |
28664048680691370732745700648196881707
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterSockRelease(WriterSock *wrSockPtr) {
SpoolerQueue *queuePtr;
NS_NONNULL_ASSERT(wrSockPtr != NULL);
wrSockPtr->refCount --;
Ns_Log(DriverDebug, "WriterSockRelease %p refCount %d keep %d",
(void *)wrSockPtr, wrSockPtr->refCount, wrSockPtr->keep);
if (wrSockPtr->refCount > 0) {
return;
}
Ns_Log(DriverDebug,
"Writer: closed sock %d, file fd %d, error %d/%d, "
"sent=%" TCL_LL_MODIFIER "d, flags=%X",
wrSockPtr->sockPtr->sock, wrSockPtr->fd,
wrSockPtr->status, wrSockPtr->err,
wrSockPtr->nsent, wrSockPtr->flags);
NsPoolAddBytesSent(wrSockPtr->poolPtr, wrSockPtr->nsent);
if (wrSockPtr->doStream != NS_WRITER_STREAM_NONE) {
Conn *connPtr;
NsWriterLock();
connPtr = wrSockPtr->connPtr;
if (connPtr != NULL && connPtr->strWriter != NULL) {
connPtr->strWriter = NULL;
}
NsWriterUnlock();
/*
* In case, writer streams are activated for this wrSockPtr, make sure
* to release the tmp file. See thread Naviserver Open Files on the
* sourceforge mailing list (starting July 2019).
*/
if (wrSockPtr->doStream == NS_WRITER_STREAM_FINISH) {
Ns_ReleaseTemp(wrSockPtr->fd);
}
}
/*
* Remove the entry from the queue and decrement counter
*/
queuePtr = wrSockPtr->queuePtr;
if (queuePtr->curPtr == wrSockPtr) {
queuePtr->curPtr = wrSockPtr->nextPtr;
queuePtr->queuesize--;
} else {
WriterSock *curPtr, *lastPtr = queuePtr->curPtr;
for (curPtr = (lastPtr != NULL) ? lastPtr->nextPtr : NULL;
curPtr != NULL;
lastPtr = curPtr, curPtr = curPtr->nextPtr
) {
if (curPtr == wrSockPtr) {
lastPtr->nextPtr = wrSockPtr->nextPtr;
queuePtr->queuesize--;
break;
}
}
}
if ((wrSockPtr->err != 0) || (wrSockPtr->status != SPOOLER_OK)) {
int i;
/*
* Lookup the matching sockState from the spooler state. The array has
* just 5 elements, on average, just 2 comparisons are needed (since
* OK is at the end).
*/
for (i = 0; i < Ns_NrElements(spoolerStateMap); i++) {
if (spoolerStateMap[i].spoolerState == wrSockPtr->status) {
SockError(wrSockPtr->sockPtr, spoolerStateMap[i].sockState, wrSockPtr->err);
break;
}
}
NsSockClose(wrSockPtr->sockPtr, (int)NS_FALSE);
} else {
NsSockClose(wrSockPtr->sockPtr, (int)wrSockPtr->keep);
}
if (wrSockPtr->clientData != NULL) {
ns_free(wrSockPtr->clientData);
}
if (wrSockPtr->fd != NS_INVALID_FD) {
if (wrSockPtr->doStream != NS_WRITER_STREAM_FINISH) {
(void) ns_close(wrSockPtr->fd);
}
WriterSockFileVecCleanup(wrSockPtr);
} else if (wrSockPtr->c.mem.bufs != NULL) {
if (wrSockPtr->c.mem.fmap.addr != NULL) {
NsMemUmap(&wrSockPtr->c.mem.fmap);
} else {
int i;
for (i = 0; i < wrSockPtr->c.mem.nbufs; i++) {
ns_free((char *)wrSockPtr->c.mem.bufs[i].iov_base);
}
}
if (wrSockPtr->c.mem.bufs != wrSockPtr->c.mem.preallocated_bufs) {
ns_free(wrSockPtr->c.mem.bufs);
}
}
if (wrSockPtr->headerString != NULL) {
ns_free(wrSockPtr->headerString);
}
ns_free(wrSockPtr);
}
|
CWE-787
| null | 519,514 |
214336885658086437644298051282368774246
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockRead(Sock *sockPtr, int spooler, const Ns_Time *timePtr)
{
const Driver *drvPtr;
Request *reqPtr;
Tcl_DString *bufPtr;
struct iovec buf;
char tbuf[16384];
size_t buflen, nread;
ssize_t n;
SockState resultState;
NS_NONNULL_ASSERT(sockPtr != NULL);
drvPtr = sockPtr->drvPtr;
tbuf[0] = '\0';
/*
* In case of "keepwait", the accept time is not meaningful and
* reset to 0. In such cases, update "acceptTime" to the actual
* begin of a request. This part is intended for async drivers.
*/
if (sockPtr->acceptTime.sec == 0) {
assert(timePtr != NULL);
sockPtr->acceptTime = *timePtr;
}
/*
* Initialize request structure if needed.
*/
if (sockPtr->reqPtr == NULL) {
RequestNew(sockPtr);
}
/*
* On the first read, attempt to read-ahead "bufsize" bytes.
* Otherwise, read only the number of bytes left in the
* content.
*/
reqPtr = sockPtr->reqPtr;
bufPtr = &reqPtr->buffer;
if (reqPtr->length == 0u) {
nread = drvPtr->bufsize;
} else {
nread = reqPtr->length - reqPtr->avail;
}
/*
* Grow the buffer to include space for the next bytes.
*/
buflen = (size_t)bufPtr->length;
n = (ssize_t)(buflen + nread);
if (unlikely(n > drvPtr->maxinput)) {
n = (ssize_t)drvPtr->maxinput;
nread = (size_t)n - buflen;
if (nread == 0u) {
Ns_Log(DriverDebug, "SockRead: maxinput reached %" TCL_LL_MODIFIER "d",
drvPtr->maxinput);
return SOCK_ERROR;
}
}
/*
* Use temp file for content larger than "readahead" bytes.
*/
#ifndef _WIN32
if (reqPtr->coff > 0u /* We are in the content part (after the header) */
&& !reqPtr->chunkStartOff /* Never spool chunked encoded data since we decode in memory */
&& reqPtr->length > (size_t)drvPtr->readahead /* We need more data */
&& sockPtr->tfd <= 0 /* We have no spool fd */
) {
const DrvSpooler *spPtr = &drvPtr->spooler;
Ns_Log(DriverDebug, "SockRead: require tmp file for content spooling (length %" PRIuz" > readahead "
"%" TCL_LL_MODIFIER "d)",
reqPtr->length, drvPtr->readahead);
/*
* In driver mode send this Sock to the spooler thread if
* it is running
*/
if (spooler == 0 && spPtr->threads > 0) {
return SOCK_SPOOL;
}
/*
* If "maxupload" is specified and content size exceeds the configured
* values, spool uploads into normal temp file (not deleted). We do
* not want to map such large files into memory.
*/
if (drvPtr->maxupload > 0
&& reqPtr->length > (size_t)drvPtr->maxupload
) {
size_t tfileLength = strlen(drvPtr->uploadpath) + 16u;
sockPtr->tfile = ns_malloc(tfileLength);
snprintf(sockPtr->tfile, tfileLength, "%s/%d.XXXXXX", drvPtr->uploadpath, sockPtr->sock);
sockPtr->tfd = ns_mkstemp(sockPtr->tfile);
if (sockPtr->tfd == NS_INVALID_FD) {
Ns_Log(Error, "SockRead: cannot create spool file with template '%s': %s",
sockPtr->tfile, strerror(errno));
}
} else {
/*
* Get a temporary fd. These FDs are used for mmapping.
*/
sockPtr->tfd = Ns_GetTemp();
}
if (unlikely(sockPtr->tfd == NS_INVALID_FD)) {
Ns_Log(DriverDebug, "SockRead: spool fd invalid");
return SOCK_ERROR;
}
n = (ssize_t)((size_t)bufPtr->length - reqPtr->coff);
assert(n >= 0);
if (ns_write(sockPtr->tfd, bufPtr->string + reqPtr->coff, (size_t)n) != n) {
return SOCK_WRITEERROR;
}
Tcl_DStringSetLength(bufPtr, 0);
}
#endif
if (sockPtr->tfd > 0) {
buf.iov_base = tbuf;
buf.iov_len = MIN(nread, sizeof(tbuf));
} else {
Tcl_DStringSetLength(bufPtr, (int)(buflen + nread));
buf.iov_base = bufPtr->string + reqPtr->woff;
buf.iov_len = nread;
}
if (reqPtr->leftover > 0u) {
/*
* There is some leftover in the buffer, don't read but take the
* leftover instead as input.
*/
n = (ssize_t)reqPtr->leftover;
reqPtr->leftover = 0u;
buflen = 0u;
Ns_Log(DriverDebug, "SockRead receive from leftover %" PRIdz " bytes", n);
} else {
/*
* Receive actually some data from the driver.
*/
n = NsDriverRecv(sockPtr, &buf, 1, NULL);
Ns_Log(DriverDebug, "SockRead receive from network %" PRIdz " bytes sockState %.2x",
n, (int)sockPtr->recvSockState);
}
{
Ns_SockState nsSockState = sockPtr->recvSockState;
/*
* The nsSockState has one of the following values, when provided:
*
* NS_SOCK_READ, NS_SOCK_DONE, NS_SOCK_AGAIN, NS_SOCK_EXCEPTION,
* NS_SOCK_TIMEOUT
*/
switch (nsSockState) {
case NS_SOCK_TIMEOUT: NS_FALL_THROUGH; /* fall through */
case NS_SOCK_EXCEPTION:
return SOCK_READERROR;
case NS_SOCK_AGAIN:
Tcl_DStringSetLength(bufPtr, (int)buflen);
return SOCK_MORE;
case NS_SOCK_DONE:
return SOCK_CLOSE;
case NS_SOCK_READ:
break;
case NS_SOCK_CANCEL: NS_FALL_THROUGH; /* fall through */
case NS_SOCK_EXIT: NS_FALL_THROUGH; /* fall through */
case NS_SOCK_INIT: NS_FALL_THROUGH; /* fall through */
case NS_SOCK_WRITE:
Ns_Log(Warning, "SockRead received unexpected state %.2x from driver", nsSockState);
return SOCK_READERROR;
case NS_SOCK_NONE:
/*
* Old style state management based on "n" and "errno", which is
* more fragile. We keep there for old-style drivers.
*/
if (n < 0) {
Tcl_DStringSetLength(bufPtr, (int)buflen);
/*
* The driver returns -1 when the peer closed the connection, but
* clears the errno such we can distinguish from error conditions.
*/
if (errno == 0) {
return SOCK_CLOSE;
}
return SOCK_READERROR;
}
if (n == 0) {
Tcl_DStringSetLength(bufPtr, (int)buflen);
return SOCK_MORE;
}
break;
}
}
if (sockPtr->tfd > 0) {
if (ns_write(sockPtr->tfd, tbuf, (size_t)n) != n) {
return SOCK_WRITEERROR;
}
} else {
Tcl_DStringSetLength(bufPtr, (int)(buflen + (size_t)n));
}
reqPtr->woff += (size_t)n;
reqPtr->avail += (size_t)n;
/*
* This driver needs raw buffer, it is binary or non-HTTP request
*/
if ((drvPtr->opts & NS_DRIVER_NOPARSE) != 0u) {
return SOCK_READY;
}
resultState = SockParse(sockPtr);
return resultState;
}
|
CWE-787
| null | 519,515 |
134587952104952150940017463499857660398
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterSockRequire(const Conn *connPtr) {
WriterSock *wrSockPtr;
NS_NONNULL_ASSERT(connPtr != NULL);
NsWriterLock();
wrSockPtr = (WriterSock *)connPtr->strWriter;
if (wrSockPtr != NULL) {
wrSockPtr->refCount ++;
}
NsWriterUnlock();
return wrSockPtr;
}
|
CWE-787
| null | 519,516 |
264360625282302419683085500803871871904
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterSubmitObjCmd(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
int result = TCL_OK;
Ns_Conn *conn;
Tcl_Obj *dataObj;
Ns_ObjvSpec args[] = {
{"data", Ns_ObjvObj, &dataObj, NULL},
{NULL, NULL, NULL, NULL}
};
if (Ns_ParseObjv(NULL, args, interp, 2, objc, objv) != NS_OK
|| NsConnRequire(interp, NS_CONN_REQUIRE_ALL, &conn) != NS_OK) {
result = TCL_ERROR;
} else {
int size;
unsigned char *data = Tcl_GetByteArrayFromObj(dataObj, &size);
if (data != NULL) {
struct iovec vbuf;
Ns_ReturnCode status;
vbuf.iov_base = (void *)data;
vbuf.iov_len = (size_t)size;
status = NsWriterQueue(conn, (size_t)size, NULL, NULL, NS_INVALID_FD,
&vbuf, 1, NULL, 0, NS_TRUE);
Tcl_SetObjResult(interp, Tcl_NewBooleanObj(status == NS_OK ? 1 : 0));
}
}
return result;
}
|
CWE-787
| null | 519,517 |
23012083553935372531634818851639546721
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
DriverModuleInitialized(const char *module)
{
Driver *drvPtr;
bool found = NS_FALSE;
NS_NONNULL_ASSERT(module != NULL);
for (drvPtr = firstDrvPtr; drvPtr != NULL; drvPtr = drvPtr->nextPtr) {
if (strcmp(drvPtr->moduleName, module) == 0) {
found = NS_TRUE;
Ns_Log(Notice, "Driver %s is already initialized", module);
break;
}
}
return found;
}
|
CWE-787
| null | 519,518 |
102057711926243514096740485422716246943
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
LogBuffer(Ns_LogSeverity severity, const char *msg, const char *buffer, size_t len)
{
Tcl_DString ds;
NS_NONNULL_ASSERT(msg != NULL);
NS_NONNULL_ASSERT(buffer != NULL);
if (Ns_LogSeverityEnabled(severity)) {
Tcl_DStringInit(&ds);
Tcl_DStringAppend(&ds, msg, -1);
Tcl_DStringAppend(&ds, ": ", 2);
(void)Ns_DStringAppendPrintable(&ds, NS_FALSE, buffer, len);
Ns_Log(severity, "%s", ds.string);
Tcl_DStringFree(&ds);
}
}
|
CWE-787
| null | 519,519 |
284439677653969281677425392327576390295
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
PollCreate(PollData *pdata)
{
NS_NONNULL_ASSERT(pdata != NULL);
memset(pdata, 0, sizeof(PollData));
}
|
CWE-787
| null | 519,520 |
103047139235549455202773283389043686412
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsWakeupDriver(const Driver *drvPtr) {
NS_NONNULL_ASSERT(drvPtr != NULL);
SockTrigger(drvPtr->trigger[1]);
}
|
CWE-787
| null | 519,521 |
117671646880613081401179673628822149368
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
DriverAccept(Sock *sockPtr, NS_SOCKET sock)
{
socklen_t n = (socklen_t)sizeof(struct NS_SOCKADDR_STORAGE);
NS_NONNULL_ASSERT(sockPtr != NULL);
return (*sockPtr->drvPtr->acceptProc)((Ns_Sock *) sockPtr,
sock,
(struct sockaddr *) &(sockPtr->sa), &n);
}
|
CWE-787
| null | 519,522 |
257651202458642222229433893151744047493
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockQueue(Sock *sockPtr, const Ns_Time *timePtr)
{
Ns_ReturnCode result;
NS_NONNULL_ASSERT(sockPtr != NULL);
/*
* Verify the conditions. Request struct must exist already.
*/
assert(sockPtr->reqPtr != NULL);
SockSetServer(sockPtr);
assert(sockPtr->servPtr != NULL);
/*
* Actual queueing, if not ready spool to the waiting list.
*/
if (!NsQueueConn(sockPtr, timePtr)) {
result = NS_TIMEOUT;
} else {
result = NS_OK;
}
return result;
}
|
CWE-787
| null | 519,523 |
302888728514094848731309052680041998060
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
void NsWriterLock(void) {
Ns_MutexLock(&writerlock);
}
|
CWE-787
| null | 519,524 |
141083383542273855754395181545564226510
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
DriverThreadsObjCmd(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
int result = TCL_OK;
if (Ns_ParseObjv(NULL, NULL, interp, 2, objc, objv) != NS_OK) {
result = TCL_ERROR;
} else {
const Driver *drvPtr;
Tcl_Obj *resultObj = Tcl_NewListObj(0, NULL);
/*
* Iterate over all drivers and collect results.
*/
for (drvPtr = firstDrvPtr; drvPtr != NULL; drvPtr = drvPtr->nextPtr) {
Tcl_ListObjAppendElement(interp, resultObj, Tcl_NewStringObj(drvPtr->threadName, -1));
}
Tcl_SetObjResult(interp, resultObj);
}
return result;
}
|
CWE-787
| null | 519,525 |
181636933617612402837237471003897492252
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsTclAsyncLogfileObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
const Ns_SubCmdSpec subcmds[] = {
{"open", AsyncLogfileOpenObjCmd},
{"write", AsyncLogfileWriteObjCmd},
{"close", AsyncLogfileCloseObjCmd},
{NULL, NULL}
};
return Ns_SubcmdObjv(subcmds, clientData, interp, objc, objv);
}
|
CWE-787
| null | 519,526 |
130411203500437810400090173191987338142
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
PollReset(PollData *pdata)
{
NS_NONNULL_ASSERT(pdata != NULL);
pdata->nfds = 0u;
pdata->timeout.sec = TIME_T_MAX;
pdata->timeout.usec = 0;
}
|
CWE-787
| null | 519,527 |
86345951964384774453736478059052856859
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
AsyncWriterRelease(AsyncWriteData *wdPtr)
{
NS_NONNULL_ASSERT(wdPtr != NULL);
ns_free(wdPtr->data);
ns_free(wdPtr);
}
|
CWE-787
| null | 519,528 |
137298694546818926203930684141589878673
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
DriverListen(Driver *drvPtr, const char *bindaddr)
{
NS_SOCKET sock;
NS_NONNULL_ASSERT(drvPtr != NULL);
NS_NONNULL_ASSERT(bindaddr != NULL);
sock = (*drvPtr->listenProc)((Ns_Driver *) drvPtr,
bindaddr,
drvPtr->port,
drvPtr->backlog,
drvPtr->reuseport);
if (sock == NS_INVALID_SOCKET) {
Ns_Log(Error, "%s: failed to listen on [%s]:%d: %s",
drvPtr->threadName, bindaddr, drvPtr->port,
ns_sockstrerror(ns_sockerrno));
} else {
Ns_Log(Notice,
#ifdef HAVE_IPV6
"%s: listening on [%s]:%d",
#else
"%s: listening on %s:%d",
#endif
drvPtr->threadName, bindaddr, drvPtr->port);
}
return sock;
}
|
CWE-787
| null | 519,529 |
160474794809668688018381804406879367210
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsAsyncWriterQueueDisable(bool shutdown)
{
if (asyncWriter != NULL) {
SpoolerQueue *queuePtr = asyncWriter->firstPtr;
Ns_Time timeout;
assert(queuePtr != NULL);
Ns_GetTime(&timeout);
Ns_IncrTime(&timeout, nsconf.shutdowntimeout.sec, nsconf.shutdowntimeout.usec);
Ns_MutexLock(&queuePtr->lock);
queuePtr->stopped = NS_TRUE;
queuePtr->shutdown = shutdown;
/*
* Trigger the AsyncWriter Thread to drain the spooler queue.
*/
SockTrigger(queuePtr->pipe[1]);
(void)Ns_CondTimedWait(&queuePtr->cond, &queuePtr->lock, &timeout);
Ns_MutexUnlock(&queuePtr->lock);
if (shutdown) {
ns_free(queuePtr);
ns_free(asyncWriter);
asyncWriter = NULL;
}
}
}
|
CWE-787
| null | 519,530 |
72870883136688937231033861954690431923
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockTrigger(NS_SOCKET sock)
{
if (send(sock, NS_EMPTY_STRING, 1, 0) != 1) {
const char *errstr = ns_sockstrerror(ns_sockerrno);
Ns_Log(Error, "driver: trigger send() failed: %s", errstr);
}
}
|
CWE-787
| null | 519,531 |
204628096612698142379959708710779116935
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
void NsWriterUnlock(void) {
Ns_MutexUnlock(&writerlock);
}
|
CWE-787
| null | 519,532 |
52800676918069623207013251902361898849
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterSubmitFileObjCmd(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
int result = TCL_OK;
Ns_Conn *conn;
char *fileNameString;
int headers = 0;
Tcl_WideInt offset = 0, size = 0;
Ns_ObjvValueRange offsetRange = {0, LLONG_MAX};
Ns_ObjvValueRange sizeRange = {1, LLONG_MAX};
Ns_ObjvSpec lopts[] = {
{"-headers", Ns_ObjvBool, &headers, INT2PTR(NS_TRUE)},
{"-offset", Ns_ObjvMemUnit, &offset, &offsetRange},
{"-size", Ns_ObjvMemUnit, &size, &sizeRange},
{NULL, NULL, NULL, NULL}
};
Ns_ObjvSpec args[] = {
{"file", Ns_ObjvString, &fileNameString, NULL},
{NULL, NULL, NULL, NULL}
};
if (unlikely(Ns_ParseObjv(lopts, args, interp, 2, objc, objv) != NS_OK)
|| NsConnRequire(interp, NS_CONN_REQUIRE_ALL, &conn) != NS_OK) {
result = TCL_ERROR;
} else if (unlikely( Ns_ConnSockPtr(conn) == NULL )) {
Ns_Log(Warning,
"NsWriterQueue: called without valid sockPtr, maybe connection already closed");
Ns_TclPrintfResult(interp, "0");
result = TCL_OK;
} else {
size_t nrbytes = 0u;
int fd = NS_INVALID_FD;
result = WriterCheckInputParams(interp, fileNameString,
(size_t)size, offset,
&fd, &nrbytes);
if (likely(result == TCL_OK)) {
Ns_ReturnCode status;
/*
* The caller requested that we build required headers
*/
if (headers != 0) {
Ns_ConnSetTypeHeader(conn, Ns_GetMimeType(fileNameString));
}
status = NsWriterQueue(conn, nrbytes, NULL, NULL, fd, NULL, 0, NULL, 0, NS_TRUE);
Tcl_SetObjResult(interp, Tcl_NewBooleanObj(status == NS_OK ? 1 : 0));
if (fd != NS_INVALID_FD) {
(void) ns_close(fd);
} else {
Ns_Log(Warning, "WriterSubmitFileObjCmd called with invalid fd");
}
} else if (fd != NS_INVALID_FD) {
(void) ns_close(fd);
}
}
return result;
}
|
CWE-787
| null | 519,533 |
333469150760734671803745908621506021895
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsAsyncWrite(int fd, const char *buffer, size_t nbyte)
{
Ns_ReturnCode returnCode = NS_OK;
NS_NONNULL_ASSERT(buffer != NULL);
/*
* If the async writer has not started or is deactivated, behave like a
* ns_write() command. If the ns_write() fails, we can't do much, since
* the writing of an error message to the log might bring us into an
* infinite loop. So we print simple to stderr.
*/
if (asyncWriter == NULL || asyncWriter->firstPtr->stopped) {
ssize_t written = ns_write(fd, buffer, nbyte);
if (unlikely(written != (ssize_t)nbyte)) {
int retries = 100;
/*
* Don't go into an infinite loop when multiple subsequent disk
* write operations return 0 (maybe disk full).
*/
returnCode = NS_ERROR;
do {
if (written < 0) {
fprintf(stderr, "error during async write (fd %d): %s\n",
fd, strerror(errno));
break;
}
/*
* All partial writes (written >= 0)
*/
WriteWarningRaw("partial write", fd, nbyte, written);
nbyte -= (size_t)written;
buffer += written;
written = ns_write(fd, buffer, nbyte);
if (written == (ssize_t)nbyte) {
returnCode = NS_OK;
break;
}
} while (retries-- > 0);
}
} else {
SpoolerQueue *queuePtr;
bool trigger = NS_FALSE;
const AsyncWriteData *wdPtr;
AsyncWriteData *newWdPtr;
/*
* Allocate a writer cmd and initialize it. In order to provide an
* interface compatible to ns_write(), we copy the provided data,
* such it can be freed by the caller. When we would give up the
* interface, we could free the memory block after writing, and
* save a malloc/free operation on the data.
*/
newWdPtr = ns_calloc(1u, sizeof(AsyncWriteData));
newWdPtr->fd = fd;
newWdPtr->bufsize = nbyte;
newWdPtr->data = ns_malloc(nbyte + 1u);
memcpy(newWdPtr->data, buffer, newWdPtr->bufsize);
newWdPtr->buf = newWdPtr->data;
newWdPtr->size = newWdPtr->bufsize;
/*
* Now add new writer socket to the writer thread's queue. In most
* cases, the queue will be empty.
*/
queuePtr = asyncWriter->firstPtr;
assert(queuePtr != NULL);
Ns_MutexLock(&queuePtr->lock);
wdPtr = queuePtr->sockPtr;
if (wdPtr != NULL) {
newWdPtr->nextPtr = queuePtr->sockPtr;
queuePtr->sockPtr = newWdPtr;
} else {
queuePtr->sockPtr = newWdPtr;
trigger = NS_TRUE;
}
Ns_MutexUnlock(&queuePtr->lock);
/*
* Wake up writer thread if desired
*/
if (trigger) {
SockTrigger(queuePtr->pipe[1]);
}
}
return returnCode;
}
|
CWE-787
| null | 519,534 |
337247893204262110834771758841982600211
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockClose(Sock *sockPtr, int keep)
{
NS_NONNULL_ASSERT(sockPtr != NULL);
if (keep != 0) {
bool driverKeep = DriverKeep(sockPtr);
keep = (int)driverKeep;
}
if (keep == (int)NS_FALSE) {
DriverClose(sockPtr);
}
Ns_MutexLock(&sockPtr->drvPtr->lock);
sockPtr->keep = (bool)keep;
Ns_MutexUnlock(&sockPtr->drvPtr->lock);
/*
* Unconditionally remove temporary file, connection thread
* should take care about very large uploads.
*/
if (sockPtr->tfile != NULL) {
unlink(sockPtr->tfile);
ns_free(sockPtr->tfile);
sockPtr->tfile = NULL;
if (sockPtr->tfd > 0) {
/*
* Close and reset fd. The fd should be > 0 unless we are in error
* conditions.
*/
(void) ns_close(sockPtr->tfd);
}
sockPtr->tfd = 0;
} else if (sockPtr->tfd > 0) {
/*
* This must be a fd allocated via Ns_GetTemp();
*/
Ns_ReleaseTemp(sockPtr->tfd);
sockPtr->tfd = 0;
}
#ifndef _WIN32
/*
* Un-map temp file used for spooled content.
*/
if (sockPtr->taddr != NULL) {
munmap(sockPtr->taddr, (size_t)sockPtr->tsize);
sockPtr->taddr = NULL;
}
#endif
}
|
CWE-787
| null | 519,535 |
260200947988125274381462339329987999974
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterStreamingObjCmd(ClientData UNUSED(clientData), Tcl_Interp *interp,
int objc, Tcl_Obj *const* objv)
{
int boolValue = -1, result = TCL_OK;
Tcl_Obj *driverObj = NULL;
Ns_Conn *conn = NULL;
const char *firstArgString;
Ns_ObjvSpec *opts, optsNew[] = {
{"-driver", Ns_ObjvObj, &driverObj, NULL},
{NULL, NULL, NULL, NULL}
};
Ns_ObjvSpec *args, argsNew[] = {
{"?value", Ns_ObjvBool, &boolValue, NULL},
{NULL, NULL, NULL, NULL}
};
Ns_ObjvSpec argsLegacy[] = {
{"driver", Ns_ObjvObj, &driverObj, NULL},
{"?value", Ns_ObjvBool, &boolValue, NULL},
{NULL, NULL, NULL, NULL}
};
firstArgString = objc > 2 ? Tcl_GetString(objv[2]) : NULL;
if (firstArgString != NULL) {
int argValue;
if (*firstArgString != '-'
&& ((objc == 3 && Tcl_ExprBoolean(interp, firstArgString, &argValue) == TCL_OK) ||
objc == 4)) {
args = argsLegacy;
opts = NULL;
Ns_LogDeprecated(objv, objc, "ns_writer streaming ?-driver drv? ?value?", NULL);
} else {
args = argsNew;
opts = optsNew;
}
} else {
args = argsNew;
opts = optsNew;
}
if (Ns_ParseObjv(opts, args, interp, 2, objc, objv) != NS_OK) {
result = TCL_ERROR;
} else if ((driverObj == NULL)
&& NsConnRequire(interp, NS_CONN_REQUIRE_ALL, &conn) != NS_OK) {
result = TCL_ERROR;
} else {
DrvWriter *wrPtr;
if (DriverWriterFromObj(interp, driverObj, conn, &wrPtr) != NS_OK) {
result = TCL_ERROR;
} else if (boolValue != -1) {
/*
* The optional argument was provided.
*/
wrPtr->doStream = (boolValue == 1 ? NS_WRITER_STREAM_ACTIVE : NS_WRITER_STREAM_NONE);
}
if (result == TCL_OK) {
Tcl_SetObjResult(interp, Tcl_NewIntObj(wrPtr->doStream == NS_WRITER_STREAM_ACTIVE ? 1 : 0));
}
}
return result;
}
|
CWE-787
| null | 519,536 |
119108586436480709015752843146158009695
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
DriverNamesObjCmd(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
int result = TCL_OK;
if (Ns_ParseObjv(NULL, NULL, interp, 2, objc, objv) != NS_OK) {
result = TCL_ERROR;
} else {
const Driver *drvPtr;
Tcl_Obj *resultObj = Tcl_NewListObj(0, NULL);
Tcl_HashTable driverNames; /* names of the drivers without duplicates */
Tcl_InitHashTable(&driverNames, TCL_STRING_KEYS);
/*
* Iterate over all drivers and collect results.
*/
for (drvPtr = firstDrvPtr; drvPtr != NULL; drvPtr = drvPtr->nextPtr) {
int isNew;
(void)Tcl_CreateHashEntry(&driverNames, drvPtr->moduleName, &isNew);
if (isNew == 1) {
Tcl_ListObjAppendElement(interp, resultObj, Tcl_NewStringObj(drvPtr->moduleName, -1));
}
}
Tcl_SetObjResult(interp, resultObj);
Tcl_DeleteHashTable(&driverNames);
}
return result;
}
|
CWE-787
| null | 519,537 |
239069556713168767313053500953352129023
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
EndOfHeader(Sock *sockPtr)
{
Request *reqPtr;
const char *s;
NS_NONNULL_ASSERT(sockPtr != NULL);
reqPtr = sockPtr->reqPtr;
assert(reqPtr != NULL);
reqPtr->chunkStartOff = 0u;
/*
* Check for "expect: 100-continue" and clear flag in case we have
* pipelining.
*/
sockPtr->flags &= ~(NS_CONN_CONTINUE);
s = Ns_SetIGet(reqPtr->headers, "expect");
if (s != NULL) {
if (*s == '1' && *(s+1) == '0' && *(s+2) == '0' && *(s+3) == '-') {
char *dup = ns_strdup(s+4);
Ns_StrToLower(dup);
if (STREQ(dup, "continue")) {
sockPtr->flags |= NS_CONN_CONTINUE;
}
ns_free(dup);
}
}
/*
* Handle content-length, which might be provided or not.
* Clear length specific error flags.
*/
sockPtr->flags &= ~(NS_CONN_ENTITYTOOLARGE);
s = Ns_SetIGet(reqPtr->headers, "content-length");
if (s == NULL) {
s = Ns_SetIGet(reqPtr->headers, "Transfer-Encoding");
if (s != NULL) {
/* Lower case is in the standard, capitalized by macOS */
if (STREQ(s, "chunked") || STREQ(s, "Chunked")) {
Tcl_WideInt expected;
reqPtr->chunkStartOff = reqPtr->roff;
reqPtr->chunkWriteOff = reqPtr->chunkStartOff;
reqPtr->contentLength = 0u;
/*
* We need reqPtr->expectedLength for safely terminating read loop.
*/
s = Ns_SetIGet(reqPtr->headers, "X-Expected-Entity-Length");
if ((s != NULL)
&& (Ns_StrToWideInt(s, &expected) == NS_OK)
&& (expected > 0) ) {
reqPtr->expectedLength = (size_t)expected;
}
s = NULL;
}
}
}
/*
* In case a valid and meaningful was provided, the string with the
* content length ("s") is not NULL.
*/
if (s != NULL) {
Tcl_WideInt length;
if ((Ns_StrToWideInt(s, &length) == NS_OK) && (length > 0)) {
reqPtr->length = (size_t)length;
/*
* Handle too large input requests.
*/
if (reqPtr->length > (size_t)sockPtr->drvPtr->maxinput) {
Ns_Log(Warning, "SockParse: request too large, length=%"
PRIdz ", maxinput=%" TCL_LL_MODIFIER "d",
reqPtr->length, sockPtr->drvPtr->maxinput);
sockPtr->keep = NS_FALSE;
sockPtr->flags |= NS_CONN_ENTITYTOOLARGE;
}
reqPtr->contentLength = (size_t)length;
}
}
/*
* Compression format handling: parse information from request headers
* indicating allowed compression formats for quick access.
*
* Clear compression accepted flag
*/
sockPtr->flags &= ~(NS_CONN_ZIPACCEPTED|NS_CONN_BROTLIACCEPTED);
s = Ns_SetIGet(reqPtr->headers, "Accept-Encoding");
if (s != NULL) {
bool gzipAccept, brotliAccept;
/*
* Get allowed compression formats from "accept-encoding" headers.
*/
NsParseAcceptEncoding(reqPtr->request.version, s, &gzipAccept, &brotliAccept);
if (gzipAccept || brotliAccept) {
/*
* Don't allow compression formats for Range requests.
*/
s = Ns_SetIGet(reqPtr->headers, "Range");
if (s == NULL) {
if (gzipAccept) {
sockPtr->flags |= NS_CONN_ZIPACCEPTED;
}
if (brotliAccept) {
sockPtr->flags |= NS_CONN_BROTLIACCEPTED;
}
}
}
}
/*
* Set up request length for spooling and further read operations
*/
if (reqPtr->contentLength != 0u) {
/*
* Content-Length was provided, use it
*/
reqPtr->length = reqPtr->contentLength;
}
return reqPtr->roff;
}
|
CWE-787
| null | 519,538 |
280779825975969467830715168499915048403
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsInitDrivers(void)
{
DriverDebug = Ns_CreateLogSeverity("Debug(ns:driver)");
WriterDebug = Ns_CreateLogSeverity("Debug(writer)");
Ns_LogTaskDebug = Ns_CreateLogSeverity("Debug(task)");
Ns_LogRequestDebug = Ns_CreateLogSeverity("Debug(request)");
Ns_LogConnchanDebug = Ns_CreateLogSeverity("Debug(connchan)");
Ns_LogUrlspaceDebug = Ns_CreateLogSeverity("Debug(urlspace)");
Ns_LogAccessDebug = Ns_CreateLogSeverity("Debug(access)");
Ns_LogTimeoutDebug = Ns_CreateLogSeverity("Debug(timeout)");
Ns_MutexInit(&reqLock);
Ns_MutexInit(&writerlock);
Ns_MutexSetName2(&reqLock, "ns:driver", "requestpool");
Ns_MutexSetName2(&writerlock, "ns:writer", "stream");
}
|
CWE-787
| null | 519,539 |
67256478901053213624905157306231928390
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
SockPoll(Sock *sockPtr, short type, PollData *pdata)
{
NS_NONNULL_ASSERT(sockPtr != NULL);
NS_NONNULL_ASSERT(pdata != NULL);
sockPtr->pidx = PollSet(pdata, sockPtr->sock, type, &sockPtr->timeout);
}
|
CWE-787
| null | 519,540 |
113838905183458132892333584994227066432
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
WriterSizeObjCmd(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
int result = TCL_OK;
Tcl_Obj *driverObj = NULL;
Ns_Conn *conn = NULL;
Tcl_WideInt intValue = -1;
const char *firstArgString;
Ns_ObjvValueRange range = {1024, INT_MAX};
Ns_ObjvSpec *opts, optsNew[] = {
{"-driver", Ns_ObjvObj, &driverObj, NULL},
{NULL, NULL, NULL, NULL}
};
Ns_ObjvSpec *args, argsNew[] = {
{"?value", Ns_ObjvMemUnit, &intValue, &range},
{NULL, NULL, NULL, NULL}
};
Ns_ObjvSpec argsLegacy[] = {
{"driver", Ns_ObjvObj, &driverObj, NULL},
{"?value", Ns_ObjvMemUnit, &intValue, &range},
{NULL, NULL, NULL, NULL}
};
firstArgString = objc > 2 ? Tcl_GetString(objv[2]) : NULL;
if (firstArgString != NULL) {
if (*firstArgString != '-'
&& ((objc == 3 && CHARTYPE(digit, *firstArgString) == 0) ||
objc == 4)) {
args = argsLegacy;
opts = NULL;
Ns_LogDeprecated(objv, objc, "ns_writer size ?-driver drv? ?size?", NULL);
} else {
args = argsNew;
opts = optsNew;
}
} else {
args = argsNew;
opts = optsNew;
}
if (Ns_ParseObjv(opts, args, interp, 2, objc, objv) != NS_OK) {
result = TCL_ERROR;
} else if ((driverObj == NULL)
&& NsConnRequire(interp, NS_CONN_REQUIRE_ALL, &conn) != NS_OK) {
result = TCL_ERROR;
} else {
DrvWriter *wrPtr;
if (DriverWriterFromObj(interp, driverObj, conn, &wrPtr) != NS_OK) {
result = TCL_ERROR;
} else if (intValue != -1) {
/*
* The optional argument was provided.
*/
wrPtr->writersize = (size_t)intValue;
}
if (result == TCL_OK) {
Tcl_SetObjResult(interp, Tcl_NewIntObj((int)wrPtr->writersize));
}
}
return result;
}
|
CWE-787
| null | 519,541 |
105506846164293133079345067029814302251
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
DriverInfoObjCmd(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
{
int result = TCL_OK;
if (Ns_ParseObjv(NULL, NULL, interp, 2, objc, objv) != NS_OK) {
result = TCL_ERROR;
} else {
const Driver *drvPtr;
Tcl_Obj *resultObj = Tcl_NewListObj(0, NULL);
Tcl_HashTable driverNames; /* names of the driver modules without duplicates */
Tcl_InitHashTable(&driverNames, TCL_STRING_KEYS);
/*
* Iterate over all modules, not necessarily all driver threads
*/
for (drvPtr = firstDrvPtr; drvPtr != NULL; drvPtr = drvPtr->nextPtr) {
int isNew = 0;
(void)Tcl_CreateHashEntry(&driverNames, drvPtr->moduleName, &isNew);
if (isNew == 1) {
Tcl_Obj *listObj = Tcl_NewListObj(0, NULL);
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("module", 6));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(drvPtr->moduleName, -1));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("type", 4));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(drvPtr->type, -1));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("server", 6));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(drvPtr->server != NULL ?
drvPtr->server : NS_EMPTY_STRING, -1));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("location", 8));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(drvPtr->location, -1));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("address", 7));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(drvPtr->address, -1));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("protocol", 8));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(drvPtr->protocol, -1));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("sendwait", 8));
Tcl_ListObjAppendElement(interp, listObj, Ns_TclNewTimeObj(&drvPtr->sendwait));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("recvwait", 8));
Tcl_ListObjAppendElement(interp, listObj, Ns_TclNewTimeObj(&drvPtr->sendwait));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("extraheaders", 12));
if (drvPtr->extraHeaders != NULL) {
Tcl_DString ds;
Tcl_DStringInit(&ds);
Ns_DStringAppendSet(&ds, drvPtr->extraHeaders);
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(ds.string, ds.length));
Tcl_DStringFree(&ds);
} else {
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("", 0));
}
Tcl_ListObjAppendElement(interp, resultObj, listObj);
}
}
Tcl_SetObjResult(interp, resultObj);
Tcl_DeleteHashTable(&driverNames);
}
return result;
}
|
CWE-787
| null | 519,542 |
112990407439428612807628266374374855642
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsAsyncWriterQueueEnable(void)
{
if (Ns_ConfigBool(NS_CONFIG_PARAMETERS, "asynclogwriter", NS_FALSE) == NS_TRUE) {
SpoolerQueue *queuePtr;
/*
* In case, the async writer has not started, the static variable
* asyncWriter is NULL.
*/
if (asyncWriter == NULL) {
Ns_MutexLock(&reqLock);
if (likely(asyncWriter == NULL)) {
/*
* Allocate and initialize writer thread context.
*/
asyncWriter = ns_calloc(1u, sizeof(AsyncWriter));
Ns_MutexUnlock(&reqLock);
Ns_MutexSetName2(&asyncWriter->lock, "ns:driver", "async-writer");
/*
* Allocate and initialize a Spooler Queue for this thread.
*/
queuePtr = ns_calloc(1u, sizeof(SpoolerQueue));
Ns_MutexSetName2(&queuePtr->lock, "ns:driver:async-writer", "queue");
asyncWriter->firstPtr = queuePtr;
/*
* Start the spooler queue
*/
SpoolerQueueStart(queuePtr, AsyncWriterThread);
} else {
Ns_MutexUnlock(&reqLock);
}
}
assert(asyncWriter != NULL);
queuePtr = asyncWriter->firstPtr;
assert(queuePtr != NULL);
Ns_MutexLock(&queuePtr->lock);
queuePtr->stopped = NS_FALSE;
Ns_MutexUnlock(&queuePtr->lock);
}
}
|
CWE-787
| null | 519,543 |
278148558721036861295619878824251820979
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
NsSockClose(Sock *sockPtr, int keep)
{
Driver *drvPtr;
bool trigger = NS_FALSE;
NS_NONNULL_ASSERT(sockPtr != NULL);
drvPtr = sockPtr->drvPtr;
Ns_Log(DriverDebug, "NsSockClose sockPtr %p (%d) keep %d",
(void *)sockPtr, ((Ns_Sock*)sockPtr)->sock, keep);
SockClose(sockPtr, keep);
/*
* Free the request, unless it is from a non-HTTP driver (who might not
* fill out the request structure).
*/
if (sockPtr->reqPtr != NULL) {
Ns_Log(DriverDebug, "NsSockClose calls RequestFree");
RequestFree(sockPtr);
}
Ns_MutexLock(&drvPtr->lock);
if (drvPtr->closePtr == NULL) {
trigger = NS_TRUE;
}
sockPtr->nextPtr = drvPtr->closePtr;
drvPtr->closePtr = sockPtr;
Ns_MutexUnlock(&drvPtr->lock);
if (trigger) {
SockTrigger(drvPtr->trigger[1]);
}
}
|
CWE-787
| null | 519,544 |
173348100641518284781392957570069247855
| null | null |
other
|
naviserver
|
a5c3079f1d8996d5f34c9384a440acf3519ca3bb
| 0 |
AsyncWriterThread(void *arg)
{
SpoolerQueue *queuePtr = (SpoolerQueue*)arg;
char charBuffer[1];
int pollTimeout;
Ns_ReturnCode status;
bool stopping;
AsyncWriteData *curPtr, *nextPtr, *writePtr;
PollData pdata;
Ns_ThreadSetName("-asynclogwriter%d-", queuePtr->id);
queuePtr->threadName = Ns_ThreadGetName();
/*
* Allocate and initialize controlling variables
*/
PollCreate(&pdata);
writePtr = NULL;
stopping = NS_FALSE;
/*
* Loop forever until signaled to shutdown and all
* connections are complete and gracefully closed.
*/
while (!stopping) {
/*
* Always listen to the trigger pipe. We could as well perform
* in the writer thread async write operations, but for the
* effect of reducing latency in connection threads, this is
* not an issue. To keep things simple, we perform the
* typically small write operations without testing for POLLOUT.
*/
PollReset(&pdata);
(void)PollSet(&pdata, queuePtr->pipe[0], (short)POLLIN, NULL);
if (writePtr == NULL) {
pollTimeout = 30 * 1000;
} else {
pollTimeout = 0;
}
/*
* Wait for data
*/
/*n =*/ (void) PollWait(&pdata, pollTimeout);
/*
* Select and drain the trigger pipe if necessary.
*/
if (PollIn(&pdata, 0)) {
if (ns_recv(queuePtr->pipe[0], charBuffer, 1u, 0) != 1) {
Ns_Fatal("asynclogwriter: trigger ns_recv() failed: %s",
ns_sockstrerror(ns_sockerrno));
}
if (queuePtr->stopped) {
/*
* Drain the queue from everything
*/
for (curPtr = writePtr; curPtr != NULL; curPtr = curPtr->nextPtr) {
ssize_t written = ns_write(curPtr->fd, curPtr->buf, curPtr->bufsize);
if (unlikely(written != (ssize_t)curPtr->bufsize)) {
WriteWarningRaw("drain writer", curPtr->fd, curPtr->bufsize, written);
}
}
writePtr = NULL;
for (curPtr = queuePtr->sockPtr; curPtr != NULL; curPtr = curPtr->nextPtr) {
ssize_t written = ns_write(curPtr->fd, curPtr->buf, curPtr->bufsize);
if (unlikely(written != (ssize_t)curPtr->bufsize)) {
WriteWarningRaw("drain queue", curPtr->fd, curPtr->bufsize, written);
}
}
queuePtr->sockPtr = NULL;
/*
* Notify the caller (normally
* NsAsyncWriterQueueDisable()) that we are done
*/
Ns_CondBroadcast(&queuePtr->cond);
}
}
/*
* Write to all available file descriptors
*/
curPtr = writePtr;
writePtr = NULL;
while (curPtr != NULL) {
ssize_t written;
nextPtr = curPtr->nextPtr;
status = NS_OK;
/*
* Write the actual data and allow for partial write operations.
*/
written = ns_write(curPtr->fd, curPtr->buf, curPtr->bufsize);
if (unlikely(written < 0)) {
status = NS_ERROR;
} else {
curPtr->size -= (size_t)written;
curPtr->nsent += written;
curPtr->bufsize -= (size_t)written;
if (curPtr->data != NULL) {
curPtr->buf += written;
}
}
if (unlikely(status != NS_OK)) {
AsyncWriterRelease(curPtr);
queuePtr->queuesize--;
} else {
/*
* The write operation was successful. Check if there
* is some remaining data to write. If not we are done
* with this request can release the write buffer.
*/
if (curPtr->size > 0u) {
Push(curPtr, writePtr);
} else {
AsyncWriterRelease(curPtr);
queuePtr->queuesize--;
}
}
curPtr = nextPtr;
}
/*
* Check for shutdown
*/
stopping = queuePtr->shutdown;
if (stopping) {
curPtr = queuePtr->sockPtr;
assert(writePtr == NULL);
while (curPtr != NULL) {
ssize_t written = ns_write(curPtr->fd, curPtr->buf, curPtr->bufsize);
if (unlikely(written != (ssize_t)curPtr->bufsize)) {
WriteWarningRaw("shutdown", curPtr->fd, curPtr->bufsize, written);
}
curPtr = curPtr->nextPtr;
}
} else {
/*
* Add fresh jobs to the writer queue. This means actually to
* move jobs from queuePtr->sockPtr (kept name for being able
* to use the same queue as above) to the currently active
* jobs in queuePtr->curPtr.
*/
Ns_MutexLock(&queuePtr->lock);
curPtr = queuePtr->sockPtr;
queuePtr->sockPtr = NULL;
while (curPtr != NULL) {
nextPtr = curPtr->nextPtr;
Push(curPtr, writePtr);
queuePtr->queuesize++;
curPtr = nextPtr;
}
queuePtr->curPtr = writePtr;
Ns_MutexUnlock(&queuePtr->lock);
}
}
PollFree(&pdata);
queuePtr->stopped = NS_TRUE;
Ns_Log(Notice, "exiting");
}
|
CWE-787
| null | 519,545 |
78947668211484363521993837000086881527
| null | null |
other
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.