dagent_cycle_t* cycle_init() { /* init dagent_cycle_t*/ dcycle = MALLOC(dagent_cycle_t, 1); /* init buffer */ dcycle->length = 0; dcycle->buffer = (char*)MALLOC(char, MAX_PACKET_LEN); /* init dcenter socket */ dcycle->socks = NULL; /* init timestamp */ time_t tt; time(&tt); dcycle->timestamp = mktime(localtime(&tt)); /* init req buffer */ dcycle->req = http_new_request(); dcycle->req->host = (char *)MALLOC(char, MAX_HOST_LEN); dcycle->req->referer = (char *)MALLOC(char, MAX_REF_LEN); dcycle->req->uri = (char *)MALLOC(char, MAX_URI_LEN); dcycle->req->url = (char *)MALLOC(char, MAX_URI_LEN); dcycle->req->user_agent = (char *)MALLOC(char, MAX_AGENT_LEN); dcycle->req->x_requested_with = (char *)MALLOC(char, MAX_REQ_WITH_LEN); dcycle->req->cookie = (char *)MALLOC(char, MAX_COOKIE_LEN); dcycle->req->saddr_str = (char *)MALLOC(char, 16); dcycle->req->daddr_str = (char *)MALLOC(char, 16); /* init mutex */ pthread_mutex_t blank_mutex = PTHREAD_MUTEX_INITIALIZER; memcpy(&dcycle->mutex, &blank_mutex, sizeof(dcycle->mutex)); //白名单过滤开关默认关闭 dcycle->white_url_flag = FALSE; /* 快速匹配的hash表 */ dcycle->hashmap = hashmap_create(MAX_BUCKETS); return dcycle; }
/* * This is annoying, but the caller needs to know the buffer size of * the request that we are using. In most cases, the passed in buffer * is what we use, so it isn't an issue, but if we malloc our own * buffer (see the HTTP_REQ_PENDING case), then the total buffer size * can grow. Thus the buff_sz argument. */ static struct http_request *connection_handle_request(struct connection *c, char *buff, int amnt, int *buff_sz) { struct http_request *r, *last; *buff_sz = amnt; r = http_new_request(c, buff, amnt); if (NULL == r) return NULL; last = r->prev; /* * If a previous request required more data to parse correctly * (was pending), then we need to combine its buffer with the * current one and try to parse again. */ if (last != r && last->flags & HTTP_REQ_PENDING) { char *new_buff; int new_len; if (last->prev != last && last->prev->flags & HTTP_REQ_PENDING) { http_free_request(r); return NULL; } new_len = amnt + last->req_len; new_buff = malloc(new_len + 1); if (NULL == new_buff) { printc("malloc fail 1\n"); fflush(stdout); http_free_request(r); return NULL; } memcpy(new_buff, last->req, last->req_len); memcpy(new_buff + last->req_len, buff, amnt); buff = new_buff; *buff_sz = amnt = new_len; new_buff[new_len] = '\0'; http_free_request(last); if (r->flags & HTTP_REQ_MALLOC) free(r->req); r->req_len = new_len; r->req = new_buff; r->flags |= HTTP_REQ_MALLOC; } /* * Process the list of requests first, then go through and * actually make the requests. */ if (http_parse_request(r)) { char *save_buff; /* parse error?! Parsing broke somewhere _in_ the * message, so we need to report this as an error */ if (r->req_len != amnt) { /* FIXME: kill connection */ http_free_request(r); return NULL; } assert(r->req_len == amnt && r->req == buff); /* * If we failed because we simply don't have a whole * message (more data is pending), then store it away * appropriately. */ save_buff = malloc(amnt + 1); if (NULL == save_buff) { printc("malloc fail 2\n"); fflush(stdout); /* FIXME: kill connection */ http_free_request(r); return NULL; } memcpy(save_buff, buff, amnt); save_buff[amnt] = '\0'; if (r->flags & HTTP_REQ_MALLOC) free(r->req); r->req = save_buff; r->flags |= (HTTP_REQ_PENDING | HTTP_REQ_MALLOC); } return r; }