/* {{{ sapi_lsapi_send_headers */ static int sapi_lsapi_send_headers(sapi_headers_struct *sapi_headers) { sapi_header_struct *h; zend_llist_position pos; if ( lsapi_mode ) { LSAPI_SetRespStatus( SG(sapi_headers).http_response_code ); h = zend_llist_get_first_ex(&sapi_headers->headers, &pos); while (h) { if ( h->header_len > 0 ) { LSAPI_AppendRespHeader(h->header, h->header_len); } h = zend_llist_get_next_ex(&sapi_headers->headers, &pos); } if (SG(sapi_headers).send_default_content_type) { char *hd; int len; char headerBuf[SAPI_LSAPI_MAX_HEADER_LENGTH]; hd = sapi_get_default_content_type(); len = snprintf( headerBuf, SAPI_LSAPI_MAX_HEADER_LENGTH - 1, "Content-type: %s", hd ); efree(hd); LSAPI_AppendRespHeader( headerBuf, len ); } } LSAPI_FinalizeRespHeaders(); return SAPI_HEADER_SENT_SUCCESSFULLY; }
void _php_curl_multi_close(zend_resource *rsrc) /* {{{ */ { php_curlm *mh = (php_curlm *)rsrc->ptr; if (mh) { zend_llist_position pos; php_curl *ch; zval *pz_ch; for (pz_ch = (zval *)zend_llist_get_first_ex(&mh->easyh, &pos); pz_ch; pz_ch = (zval *)zend_llist_get_next_ex(&mh->easyh, &pos)) { /* ptr is NULL means it already be freed */ if (Z_RES_P(pz_ch)->ptr) { if ((ch = (php_curl *) zend_fetch_resource(Z_RES_P(pz_ch), le_curl_name, le_curl))) { _php_curl_verify_handlers(ch, 0); } } } curl_multi_cleanup(mh->multi); zend_llist_clean(&mh->easyh); if (mh->handlers->server_push) { efree(mh->handlers->server_push); } if (mh->handlers) { efree(mh->handlers); } efree(mh); rsrc->ptr = NULL; } }
static int sapi_uwsgi_send_headers(sapi_headers_struct *sapi_headers) { sapi_header_struct *h; zend_llist_position pos; if (SG(request_info).no_headers == 1) { return SAPI_HEADER_SENT_SUCCESSFULLY; } struct wsgi_request *wsgi_req = (struct wsgi_request *) SG(server_context); if (!SG(sapi_headers).http_status_line) { char status[4]; int hrc = SG(sapi_headers).http_response_code; if (!hrc) hrc = 200; uwsgi_num2str2n(hrc, status, 4); uwsgi_response_prepare_headers(wsgi_req, status, 3); } else { char *sl = SG(sapi_headers).http_status_line; uwsgi_response_prepare_headers(wsgi_req, sl, strlen(sl)); } h = zend_llist_get_first_ex(&sapi_headers->headers, &pos); while (h) { uwsgi_response_add_header(wsgi_req, NULL, 0, h->header, h->header_len); h = zend_llist_get_next_ex(&sapi_headers->headers, &pos); } return SAPI_HEADER_SENT_SUCCESSFULLY; }
void apd_summary_output_elapsed_time(int filenum, int linenum, int usert, int systemt, int realt) { zend_llist *list; zend_llist_position l; apd_fcall_t *cc; TSRMLS_FETCH(); list = &APD_GLOBALS(summary).call_list; cc = zend_llist_get_first_ex(list, &l); while (cc) { cc->usertime += usert; cc->systemtime += systemt; cc->realtime += realt; cc = zend_llist_get_next_ex(list, &l); } }
/* Used to find the php_curl resource for a given curl easy handle */ static zval *_php_curl_multi_find_easy_handle(php_curlm *mh, CURL *easy) /* {{{ */ { php_curl *tmp_ch; zend_llist_position pos; zval *pz_ch_temp; for(pz_ch_temp = (zval *)zend_llist_get_first_ex(&mh->easyh, &pos); pz_ch_temp; pz_ch_temp = (zval *)zend_llist_get_next_ex(&mh->easyh, &pos)) { if ((tmp_ch = (php_curl *)zend_fetch_resource(Z_RES_P(pz_ch_temp), le_curl_name, le_curl)) == NULL) { return NULL; } if (tmp_ch->cp == easy) { return pz_ch_temp; } } return NULL; }
/* ERRORS */ static void do_from_to_zval_err(struct err_s *err, zend_llist *keys, const char *what_conv, const char *fmt, va_list ap) { smart_str path = {0}; const char **node; char *user_msg; int user_msg_size; zend_llist_position pos; if (err->has_error) { return; } for (node = zend_llist_get_first_ex(keys, &pos); node != NULL; node = zend_llist_get_next_ex(keys, &pos)) { smart_str_appends(&path, *node); smart_str_appends(&path, " > "); } if (path.s && path.s->len > 3) { path.s->len -= 3; } smart_str_0(&path); user_msg_size = vspprintf(&user_msg, 0, fmt, ap); err->has_error = 1; err->level = E_WARNING; spprintf(&err->msg, 0, "error converting %s data (path: %s): %.*s", what_conv, path.s && *path.s->val != '\0' ? path.s->val : "unavailable", user_msg_size, user_msg); err->should_free = 1; efree(user_msg); smart_str_free(&path); }
/* {{{ property link_error_list_read */ static zval *link_error_list_read(mysqli_object *obj, zval *retval) { MY_MYSQL *mysql; CHECK_STATUS(MYSQLI_STATUS_VALID); mysql = (MY_MYSQL *)((MYSQLI_RESOURCE *)(obj->ptr))->ptr; array_init(retval); if (mysql) { #if defined(MYSQLI_USE_MYSQLND) if (mysql->mysql->data->error_info->error_list) { MYSQLND_ERROR_LIST_ELEMENT * message; zend_llist_position pos; for (message = (MYSQLND_ERROR_LIST_ELEMENT *) zend_llist_get_first_ex(mysql->mysql->data->error_info->error_list, &pos); message; message = (MYSQLND_ERROR_LIST_ELEMENT *) zend_llist_get_next_ex(mysql->mysql->data->error_info->error_list, &pos)) { zval single_error; array_init(&single_error); add_assoc_long_ex(&single_error, "errno", sizeof("errno") - 1, message->error_no); add_assoc_string_ex(&single_error, "sqlstate", sizeof("sqlstate") - 1, message->sqlstate); add_assoc_string_ex(&single_error, "error", sizeof("error") - 1, message->error); add_next_index_zval(retval, &single_error); } } #else if (mysql_errno(mysql->mysql)) { zval single_error; array_init(&single_error); add_assoc_long_ex(&single_error, "errno", sizeof("errno") - 1, mysql_errno(mysql->mysql)); add_assoc_string_ex(&single_error, "sqlstate", sizeof("sqlstate") - 1, mysql_sqlstate(mysql->mysql)); add_assoc_string_ex(&single_error, "error", sizeof("error") - 1, mysql_error(mysql->mysql)); add_next_index_zval(retval, &single_error); } #endif } return retval; }
static int sapi_uwsgi_send_headers(sapi_headers_struct *sapi_headers) { sapi_header_struct *h; zend_llist_position pos; struct iovec iov[6]; char status[4]; struct http_status_codes *http_sc; if (SG(request_info).no_headers == 1) { return SAPI_HEADER_SENT_SUCCESSFULLY; } struct wsgi_request *wsgi_req = (struct wsgi_request *) SG(server_context); wsgi_req->status = SG(sapi_headers).http_response_code; if (!wsgi_req->status) wsgi_req->status = 200; if (!SG(sapi_headers).http_status_line) { iov[0].iov_base = wsgi_req->protocol; iov[0].iov_len = wsgi_req->protocol_len; iov[1].iov_base = " "; iov[1].iov_len = 1; uwsgi_num2str2n(wsgi_req->status, status, 4); iov[2].iov_base = status; iov[2].iov_len = 3; iov[3].iov_base = " "; iov[3].iov_len = 1; // get the status code for (http_sc = hsc; http_sc->message != NULL; http_sc++) { if (!strncmp(http_sc->key, status, 3)) { iov[4].iov_base = (char *) http_sc->message; iov[4].iov_len = http_sc->message_size; break; } } if (iov[4].iov_len == 0) { iov[4].iov_base = "Unknown"; iov[4].iov_len = 7; } iov[5].iov_base = "\r\n"; iov[5].iov_len = 2; wsgi_req->headers_size += wsgi_req->socket->proto_writev_header(wsgi_req, iov, 6); } else { iov[0].iov_base = SG(sapi_headers).http_status_line; iov[0].iov_len = strlen(iov[0].iov_base); iov[1].iov_base = "\r\n"; iov[1].iov_len = 2; wsgi_req->headers_size += wsgi_req->socket->proto_writev_header(wsgi_req, iov, 2); } h = zend_llist_get_first_ex(&sapi_headers->headers, &pos); while (h) { iov[0].iov_base = h->header; iov[0].iov_len = h->header_len; iov[1].iov_base = "\r\n"; iov[1].iov_len = 2; wsgi_req->headers_size += wsgi_req->socket->proto_writev_header(wsgi_req, iov, 2); wsgi_req->header_cnt++; h = zend_llist_get_next_ex(&sapi_headers->headers, &pos); } struct uwsgi_string_list *ah = uwsgi.additional_headers; while(ah) { iov[0].iov_base = ah->value; iov[0].iov_len = ah->len; iov[1].iov_base = "\r\n"; iov[1].iov_len = 2; wsgi_req->headers_size += wsgi_req->socket->proto_writev_header(wsgi_req, iov, 2); wsgi_req->header_cnt++; ah = ah->next; } ah = wsgi_req->additional_headers; while(ah) { iov[0].iov_base = ah->value; iov[0].iov_len = ah->len; iov[1].iov_base = "\r\n"; iov[1].iov_len = 2; wsgi_req->headers_size += wsgi_req->socket->proto_writev_header(wsgi_req, iov, 2); wsgi_req->header_cnt++; ah = ah->next; } wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2); return SAPI_HEADER_SENT_SUCCESSFULLY; }
int fpm_log_write(char *log_format) /* {{{ */ { char *s, *b; char buffer[FPM_LOG_BUFFER+1]; int token, test; size_t len, len2; struct fpm_scoreboard_proc_s proc, *proc_p; struct fpm_scoreboard_s *scoreboard; char tmp[129]; char format[129]; time_t now_epoch; #ifdef HAVE_TIMES clock_t tms_total; #endif if (!log_format && (!fpm_log_format || fpm_log_fd == -1)) { return -1; } if (!log_format) { log_format = fpm_log_format; test = 0; } else { test = 1; } now_epoch = time(NULL); if (!test) { scoreboard = fpm_scoreboard_get(); if (!scoreboard) { zlog(ZLOG_WARNING, "unable to get scoreboard while preparing the access log"); return -1; } proc_p = fpm_scoreboard_proc_acquire(NULL, -1, 0); if (!proc_p) { zlog(ZLOG_WARNING, "[pool %s] Unable to acquire shm slot while preparing the access log", scoreboard->pool); return -1; } proc = *proc_p; fpm_scoreboard_proc_release(proc_p); } token = 0; memset(buffer, '\0', sizeof(buffer)); b = buffer; len = 0; s = log_format; while (*s != '\0') { /* Test is we have place for 1 more char. */ if (len >= FPM_LOG_BUFFER) { zlog(ZLOG_NOTICE, "the log buffer is full (%d). The access log request has been truncated.", FPM_LOG_BUFFER); len = FPM_LOG_BUFFER; break; } if (!token && *s == '%') { token = 1; memset(format, '\0', sizeof(format)); /* reset format */ s++; continue; } if (token) { token = 0; len2 = 0; switch (*s) { case '%': /* '%' */ *b = '%'; len2 = 1; break; #ifdef HAVE_TIMES case 'C': /* %CPU */ if (format[0] == '\0' || !strcasecmp(format, "total")) { if (!test) { tms_total = proc.last_request_cpu.tms_utime + proc.last_request_cpu.tms_stime + proc.last_request_cpu.tms_cutime + proc.last_request_cpu.tms_cstime; } } else if (!strcasecmp(format, "user")) { if (!test) { tms_total = proc.last_request_cpu.tms_utime + proc.last_request_cpu.tms_cutime; } } else if (!strcasecmp(format, "system")) { if (!test) { tms_total = proc.last_request_cpu.tms_stime + proc.last_request_cpu.tms_cstime; } } else { zlog(ZLOG_WARNING, "only 'total', 'user' or 'system' are allowed as a modifier for %%%c ('%s')", *s, format); return -1; } format[0] = '\0'; if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%.2f", tms_total / fpm_scoreboard_get_tick() / (proc.cpu_duration.tv_sec + proc.cpu_duration.tv_usec / 1000000.) * 100.); } break; #endif case 'd': /* duration µs */ /* seconds */ if (format[0] == '\0' || !strcasecmp(format, "seconds")) { if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%.3f", proc.duration.tv_sec + proc.duration.tv_usec / 1000000.); } /* miliseconds */ } else if (!strcasecmp(format, "miliseconds") || !strcasecmp(format, "mili")) { if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%.3f", proc.duration.tv_sec * 1000. + proc.duration.tv_usec / 1000.); } /* microseconds */ } else if (!strcasecmp(format, "microseconds") || !strcasecmp(format, "micro")) { if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%lu", proc.duration.tv_sec * 1000000UL + proc.duration.tv_usec); } } else { zlog(ZLOG_WARNING, "only 'seconds', 'mili', 'miliseconds', 'micro' or 'microseconds' are allowed as a modifier for %%%c ('%s')", *s, format); return -1; } format[0] = '\0'; break; case 'e': /* fastcgi env */ if (format[0] == '\0') { zlog(ZLOG_WARNING, "the name of the environment variable must be set between embraces for %%%c", *s); return -1; } if (!test) { char *env = fcgi_getenv((fcgi_request*) SG(server_context), format, strlen(format)); len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", env ? env : "-"); } format[0] = '\0'; break; case 'f': /* script */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", *proc.script_filename ? proc.script_filename : "-"); } break; case 'l': /* content length */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%zu", proc.content_length); } break; case 'm': /* method */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", *proc.request_method ? proc.request_method : "-"); } break; case 'M': /* memory */ /* seconds */ if (format[0] == '\0' || !strcasecmp(format, "bytes")) { if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%zu", proc.memory); } /* kilobytes */ } else if (!strcasecmp(format, "kilobytes") || !strcasecmp(format, "kilo")) { if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%lu", proc.memory / 1024); } /* megabytes */ } else if (!strcasecmp(format, "megabytes") || !strcasecmp(format, "mega")) { if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%lu", proc.memory / 1024 / 1024); } } else { zlog(ZLOG_WARNING, "only 'bytes', 'kilo', 'kilobytes', 'mega' or 'megabytes' are allowed as a modifier for %%%c ('%s')", *s, format); return -1; } format[0] = '\0'; break; case 'n': /* pool name */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", scoreboard->pool[0] ? scoreboard->pool : "-"); } break; case 'o': /* header output */ if (format[0] == '\0') { zlog(ZLOG_WARNING, "the name of the header must be set between embraces for %%%c", *s); return -1; } if (!test) { sapi_header_struct *h; zend_llist_position pos; sapi_headers_struct *sapi_headers = &SG(sapi_headers); size_t format_len = strlen(format); h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos); while (h) { char *header; if (!h->header_len) { h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos); continue; } if (!strstr(h->header, format)) { h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos); continue; } /* test if enought char after the header name + ': ' */ if (h->header_len <= format_len + 2) { h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos); continue; } if (h->header[format_len] != ':' || h->header[format_len + 1] != ' ') { h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos); continue; } header = h->header + format_len + 2; len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", header && *header ? header : "-"); /* found, done */ break; } if (!len2) { len2 = 1; *b = '-'; } } format[0] = '\0'; break; case 'p': /* PID */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%ld", (long)getpid()); } break; case 'P': /* PID */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%ld", (long)getppid()); } break; case 'q': /* query_string */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", proc.query_string); } break; case 'Q': /* '?' */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", *proc.query_string ? "?" : ""); } break; case 'r': /* request URI */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", proc.request_uri); } break; case 'R': /* remote IP address */ if (!test) { const char *tmp = fcgi_get_last_client_ip(); len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", tmp ? tmp : "-"); } break; case 's': /* status */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%d", SG(sapi_headers).http_response_code); } break; case 'T': case 't': /* time */ if (!test) { time_t *t; if (*s == 't') { t = &proc.accepted_epoch; } else { t = &now_epoch; } if (format[0] == '\0') { strftime(tmp, sizeof(tmp) - 1, "%d/%b/%Y:%H:%M:%S %z", localtime(t)); } else { strftime(tmp, sizeof(tmp) - 1, format, localtime(t)); } len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", tmp); } format[0] = '\0'; break; case 'u': /* remote user */ if (!test) { len2 = snprintf(b, FPM_LOG_BUFFER - len, "%s", proc.auth_user); } break; case '{': /* complex var */ token = 1; { char *start; size_t l; start = ++s; while (*s != '\0') { if (*s == '}') { l = s - start; if (l >= sizeof(format) - 1) { l = sizeof(format) - 1; } memcpy(format, start, l); format[l] = '\0'; break; } s++; } if (s[1] == '\0') { zlog(ZLOG_WARNING, "missing closing embrace in the access.format"); return -1; } } break; default: zlog(ZLOG_WARNING, "Invalid token in the access.format (%%%c)", *s); return -1; } if (*s != '}' && format[0] != '\0') { zlog(ZLOG_WARNING, "embrace is not allowed for modifier %%%c", *s); return -1; } s++; if (!test) { b += len2; len += len2; } continue; } if (!test) { // push the normal char to the output buffer *b = *s; b++; len++; } s++; } if (!test && strlen(buffer) > 0) { buffer[len] = '\n'; write(fpm_log_fd, buffer, len + 1); } return 0; }
static int sapi_tux_send_headers(sapi_headers_struct *sapi_headers) { char buf[1024]; struct iovec *vec; int n; int max_headers; zend_llist_position pos; sapi_header_struct *h; size_t len; char *status_line; int locate_cl; TSRMLS_FETCH(); max_headers = 30; n = 1; vec = malloc(sizeof(struct iovec) * max_headers); status_line = malloc(30); /* safe sprintf use */ len = slprintf(status_line, 30, "HTTP/1.1 %d NA\r\n", SG(sapi_headers).http_response_code); vec[0].iov_base = status_line; vec[0].iov_len = len; TG(req)->http_status = SG(sapi_headers).http_response_code; if (TG(tux_action) == TUX_ACTION_FINISH_CLOSE_REQ && TG(req)->http_version == HTTP_1_1) locate_cl = 1; else locate_cl = 0; h = zend_llist_get_first_ex(&sapi_headers->headers, &pos); while (h) { if (locate_cl && strncasecmp(h->header, "Content-length:", sizeof("Content-length:")-1) == 0) { TG(tux_action) = TUX_ACTION_FINISH_REQ; locate_cl = 0; } vec[n].iov_base = h->header; vec[n++].iov_len = h->header_len; if (n >= max_headers - 3) { max_headers *= 2; vec = realloc(vec, sizeof(struct iovec) * max_headers); } vec[n].iov_base = "\r\n"; vec[n++].iov_len = 2; h = zend_llist_get_next_ex(&sapi_headers->headers, &pos); } vec[n].iov_base = "\r\n"; vec[n++].iov_len = 2; TG(number_vec) = n; TG(header_vec) = vec; return SAPI_HEADER_SENT_SUCCESSFULLY; }