static struct _pconn * pconnNew(const char *key) { struct _pconn *p = memPoolAlloc(pconn_data_pool); p->hash.key = xstrdup(key); p->nfds_alloc = PCONN_FDS_SZ; p->fds = memPoolAlloc(pconn_fds_pool); debug(48, 3) ("pconnNew: adding %s\n", hashKeyStr(&p->hash)); hash_join(table, &p->hash); return p; }
static void authenticateAuthUserRequestLinkIp(auth_user_request_t * auth_user_request, const struct in_addr ipaddr, request_t * request) { auth_user_request_ip_hash_t *hash_entry; if (!Config.authenticateIpShortcircuitTTL) return; #ifdef CC_FRAMEWORK acl_access * acl = cc_get_acl_access_by_token_and_host("authenticate_ip_shortcircuit_access",request->host); if (acl && !aclCheckFastRequest(acl, request)) #else if (Config.accessList.auth_ip_shortcircuit && !aclCheckFastRequest(Config.accessList.auth_ip_shortcircuit, request)) #endif return; if (!auth_user_request_ip_hash) { auth_user_request_ip_hash = hash_create((HASHCMP *) cmp_in_addr, 7921, hash_in_addr); auth_user_request_ip_pool = memPoolCreate("auth_user_request_ip_hash_t", sizeof(auth_user_request_ip_hash_t)); } authenticateAuthUserRequestUnlinkIp(ipaddr); hash_entry = memPoolAlloc(auth_user_request_ip_pool); hash_entry->ipaddr = ipaddr; hash_entry->hash.key = &hash_entry->ipaddr; hash_entry->auth_user_request = auth_user_request; authenticateAuthUserRequestLock(hash_entry->auth_user_request); hash_entry->last_seen = squid_curtime; hash_join(auth_user_request_ip_hash, &hash_entry->hash); }
/*parse config line*/ static int func_sys_parse_param(char *cfg_line) { struct mod_conf_param *data = NULL; char* token = NULL; int flag = 0; int temp; if ((token = strtok(cfg_line, w_space)) != NULL) { if(strcmp(token, "mod_no_cache_if_http_code")) goto err; } else { debug(190, 3)("(mod_no_cache_if_http_code) -> parse line error\n"); goto err; } if(NULL == mod_config_pool) { mod_config_pool = memPoolCreate("mod_no_cache_if_http_code config_struct", sizeof(struct mod_conf_param)); } data = memPoolAlloc(mod_config_pool); data->count = 0; while (NULL != (token = strtok(NULL, w_space))) { if(0 != strcmp(token, "allow") || 0 != strcmp(token, "deny")) { if(49 == data->count) { debug(190, 3)("mod_no_cache_if_http_code : there are 49 values of squid`s http_code totally.\n"); flag = 1; break; } if((temp = atoi(token)) >= 0) { data->http_code[data->count++] = temp; } else { flag = 1; debug(190, 3)("mod_no_cache_if_http_code : there is something wrong during parsing the http code in config line\n"); break; } } else { flag = 0; break; } } if(1 == flag) goto err; cc_register_mod_param(mod, data, free_callback); return 0; err: free_callback(data); return -1; }
void aioStat(char *path, struct stat *sb, AIOCB * callback, void *callback_data) { aio_ctrl_t *ctrlp; assert(initialised); aio_counts.stat++; ctrlp = memPoolAlloc(aio_ctrl_pool); ctrlp->fd = -2; ctrlp->done_handler = callback; ctrlp->done_handler_data = callback_data; ctrlp->operation = _AIO_STAT; cbdataLock(callback_data); if (aio_stat(path, sb, &ctrlp->result) < 0) { if (errno == ENOMEM || errno == EAGAIN || errno == EINVAL) errno = EWOULDBLOCK; if (callback) (callback) (ctrlp->fd, callback_data, -1, errno); cbdataUnlock(callback_data); memPoolFree(aio_ctrl_pool, ctrlp); return; } ctrlp->next = used_list; used_list = ctrlp; return; } /* aioStat */
void aioOpen(const char *path, int oflag, mode_t mode, AIOCB * callback, void *callback_data) { aio_ctrl_t *ctrlp; int ret; assert(initialised); aio_counts.open++; ctrlp = memPoolAlloc(aio_ctrl_pool); ctrlp->fd = -2; ctrlp->done_handler = callback; ctrlp->done_handler_data = callback_data; ctrlp->operation = _AIO_OPEN; cbdataLock(callback_data); if (aio_open(path, oflag, mode, &ctrlp->result) < 0) { ret = open(path, oflag, mode); if (callback) (callback) (ctrlp->fd, callback_data, ret, errno); cbdataUnlock(callback_data); memPoolFree(aio_ctrl_pool, ctrlp); return; } ctrlp->next = used_list; used_list = ctrlp; return; }
void aioWrite(int fd, int offset, char *bufp, int len, AIOCB * callback, void *callback_data, FREE * free_func) { squidaio_ctrl_t *ctrlp; int seekmode; assert(initialised); squidaio_counts.write++; ctrlp = memPoolAlloc(squidaio_ctrl_pool); ctrlp->fd = fd; ctrlp->done_handler = callback; ctrlp->done_handler_data = callback_data; ctrlp->operation = _AIO_WRITE; ctrlp->bufp = bufp; ctrlp->free_func = free_func; if (offset >= 0) seekmode = SEEK_SET; else { seekmode = SEEK_END; offset = 0; } cbdataLock(callback_data); ctrlp->result.data = ctrlp; squidaio_write(fd, bufp, len, offset, seekmode, &ctrlp->result); dlinkAdd(ctrlp, &ctrlp->node, &used_list); } /* aioWrite */
void aioRead(int fd, int offset, int len, AIOCB * callback, void *callback_data) { squidaio_ctrl_t *ctrlp; int seekmode; assert(initialised); squidaio_counts.read++; ctrlp = memPoolAlloc(squidaio_ctrl_pool); ctrlp->fd = fd; ctrlp->done_handler = callback; ctrlp->done_handler_data = callback_data; ctrlp->operation = _AIO_READ; ctrlp->len = len; ctrlp->bufp = squidaio_xmalloc(len); if (offset >= 0) seekmode = SEEK_SET; else { seekmode = SEEK_CUR; offset = 0; } cbdataLock(callback_data); ctrlp->result.data = ctrlp; squidaio_read(fd, ctrlp->bufp, len, offset, seekmode, &ctrlp->result); dlinkAdd(ctrlp, &ctrlp->node, &used_list); return; } /* aioRead */
void aioUnlink(const char *pathname, AIOCB * callback, void *callback_data) { aio_ctrl_t *ctrlp; char *path; assert(initialised); aio_counts.unlink++; ctrlp = memPoolAlloc(aio_ctrl_pool); ctrlp->fd = -2; ctrlp->done_handler = callback; ctrlp->done_handler_data = callback_data; ctrlp->operation = _AIO_UNLINK; path = xstrdup(pathname); cbdataLock(callback_data); if (aio_unlink(path, &ctrlp->result) < 0) { int ret = unlink(path); (callback) (ctrlp->fd, callback_data, ret, errno); cbdataUnlock(callback_data); memPoolFree(aio_ctrl_pool, ctrlp); xfree(path); return; } ctrlp->next = used_list; used_list = ctrlp; xfree(path); } /* aioUnlink */
ChunkedBuffer *chunkedBufferAlloc(size_t length) { error_t error; ChunkedBuffer *buffer; //Allocate memory to hold the multi-part buffer buffer = memPoolAlloc(MEM_POOL_BUFFER_SIZE); //Failed to allocate memory? if(!buffer) return NULL; //The multi-part buffer consists of a single chunk buffer->chunkCount = 1; buffer->maxChunkCount = MAX_CHUNK_COUNT; buffer->chunk[0].address = (uint8_t *) buffer + MAX_CHUNK_COUNT * sizeof(ChunkDesc); buffer->chunk[0].length = MEM_POOL_BUFFER_SIZE - MAX_CHUNK_COUNT * sizeof(ChunkDesc); buffer->chunk[0].size = 0; //Adjust the length of the buffer error = chunkedBufferSetLength(buffer, length); //Any error to report? if(error) { //Clean up side effects chunkedBufferFree(buffer); //Report an failure return NULL; } //Successful memory allocation return buffer; }
storeIOState * storeDiskdCreate(SwapDir * SD, StoreEntry * e, STFNCB * file_callback, STIOCB * callback, void *callback_data) { sfileno f; int x; storeIOState *sio; char *buf; int shm_offset; diskdinfo_t *diskdinfo = SD->fsdata; diskdstate_t *diskdstate; /* * Fail on open() if there are too many requests queued. */ if (diskdinfo->away > diskdinfo->magic1) { diskd_stats.open_fail_queue_len++; return NULL; } /* Allocate a number */ f = storeDiskdDirMapBitAllocate(SD); debug(79, 3) ("storeDiskdCreate: fileno %08X\n", f); CBDATA_INIT_TYPE_FREECB(storeIOState, storeDiskdIOFreeEntry); sio = cbdataAlloc(storeIOState); sio->fsstate = diskdstate = memPoolAlloc(diskd_state_pool); sio->swap_filen = f; sio->swap_dirn = SD->index; sio->mode = O_WRONLY | O_CREAT | O_TRUNC; sio->callback = callback; sio->callback_data = callback_data; sio->e = e; cbdataLock(callback_data); diskdstate->flags.writing = 0; diskdstate->flags.reading = 0; diskdstate->flags.close_request = 0; diskdstate->id = diskd_stats.sio_id++; buf = storeDiskdShmGet(SD, &shm_offset); xstrncpy(buf, storeDiskdDirFullPath(SD, f, NULL), SHMBUF_BLKSZ); x = storeDiskdSend(_MQD_OPEN, SD, diskdstate->id, sio, strlen(buf) + 1, sio->mode, shm_offset); if (x < 0) { debug(79, 1) ("storeDiskdSend OPEN: %s\n", xstrerror()); storeDiskdShmPut(SD, shm_offset); cbdataUnlock(sio->callback_data); cbdataFree(sio); return NULL; } storeDiskdDirReplAdd(SD, e); diskd_stats.create.ops++; return sio; }
static digest_request_h * authDigestRequestNew(void) { digest_request_h *tmp; tmp = memPoolAlloc(digest_request_pool); assert(tmp != NULL); return tmp; }
static void * mod_config_pool_alloc(void) { void * obj = NULL; if (NULL == mod_config_pool) { mod_config_pool = memPoolCreate("mod_check_response config_struct", sizeof(struct mod_conf_param)); } return obj = memPoolAlloc(mod_config_pool); }
static void * mod_config_pool_alloc(void) { void * obj = NULL; if (NULL == mod_config_pool) { mod_config_pool = memPoolCreate("mod_modify_s2o_header_name config_struct", sizeof(struct mod_conf_param)); } return obj = memPoolAlloc(mod_config_pool); }
static void * timeout_pool_alloc(void) { void * obj = NULL; if(NULL == timeout_pool) { timeout_pool = memPoolCreate("mod_srv_side_errpage private_data timeout", sizeof(int)); } return obj = memPoolAlloc(timeout_pool); }
static void *mod_config_pool_alloc(void) { void * obj = NULL; if (NULL == mod_config_pool) { mod_config_pool = memPoolCreate("mod_m3u8_prefetch config_struct", sizeof(mod_config)); } return obj = memPoolAlloc(mod_config_pool); }
static void * action_part_pool_alloc(void) { void * obj = NULL; if (NULL == action_part_pool) { action_part_pool = memPoolCreate("mod_header config_struct action_part", sizeof(struct action_part)); } return obj = memPoolAlloc(action_part_pool); }
static void * header_info_pool_alloc(void) { void * obj = NULL; if (NULL == header_info_pool) { header_info_pool = memPoolCreate("mod_header config_struct header_info", sizeof(struct header_info)); } return obj = memPoolAlloc(header_info_pool); }
static void * mod_config_pool_alloc(void) { void * obj = NULL; if(NULL == mod_config_pool) { mod_config_pool = memPoolCreate("mod_srv_side_errpage config_struct", sizeof(mod_config)); } return obj = memPoolAlloc(mod_config_pool); }
static void * text_mb_pool_alloc(void) { void * obj = NULL; if(NULL == text_mb_pool) { text_mb_pool = memPoolCreate("mod_srv_side_errpage private_data text", sizeof(MemBuf)); } return obj = memPoolAlloc(text_mb_pool); }
static void * request_param_pool_alloc(void) { void * obj = NULL; if (NULL == request_param_pool) { request_param_pool = memPoolCreate("mod_m3u8_prefetch private_data request_param", sizeof(request_param)); } return obj = memPoolAlloc(request_param_pool); }
static void * error_page_private_data_pool_alloc(void) { void * obj = NULL; if (NULL == error_page_private_data_pool) { error_page_private_data_pool = memPoolCreate("mod_srv_side_errpage private_data error_page_private_data", sizeof(error_page_private_data)); } return obj = memPoolAlloc(error_page_private_data_pool); }
int squidaio_opendir(const char *path, squidaio_result_t * resultp) { squidaio_request_t *requestp; int len; requestp = memPoolAlloc(squidaio_request_pool); return -1; }
/* open for creating */ storeIOState * storeAufsCreate(SwapDir * SD, StoreEntry * e, STFNCB * file_callback, STIOCB * callback, void *callback_data) { char *path; storeIOState *sio; sfileno filn; sdirno dirn; #if !ASYNC_CREATE int fd; #endif /* Allocate a number */ dirn = SD->index; filn = storeAufsDirMapBitAllocate(SD); path = storeAufsDirFullPath(SD, filn, NULL); debug(79, 3) ("storeAufsCreate: fileno %08X\n", filn); /* * we should detect some 'too many files open' condition and return * NULL here. */ #ifdef MAGIC2 if (aioQueueSize() > MAGIC2) return NULL; #endif #if !ASYNC_CREATE fd = file_open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY); if (fd < 0) { debug(79, 3) ("storeAufsCreate: got failure (%d)\n", errno); return NULL; } #endif CBDATA_INIT_TYPE_FREECB(storeIOState, storeAufsIOFreeEntry); sio = cbdataAlloc(storeIOState); sio->fsstate = memPoolAlloc(squidaio_state_pool); ((squidaiostate_t *) (sio->fsstate))->fd = -1; ((squidaiostate_t *) (sio->fsstate))->flags.opening = 1; sio->swap_filen = filn; sio->swap_dirn = dirn; sio->mode = O_WRONLY | O_BINARY; sio->callback = callback; sio->callback_data = callback_data; sio->e = (StoreEntry *) e; cbdataLock(callback_data); Opening_FD++; statCounter.syscalls.disk.opens++; #if ASYNC_CREATE aioOpen(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644, storeAufsOpenDone, sio, INDEX_OF_SD(SD)); #else storeAufsOpenDone(fd, sio, fd, 0); #endif /* now insert into the replacement policy */ storeAufsDirReplAdd(SD, e); return sio; }
static void * is_defer_func_pool_alloc(void) { void * obj = NULL; if (NULL == is_defer_func_pool) { is_defer_func_pool = memPoolCreate("mod_helper_defer other_data link_node", sizeof(is_defer_func)); } return obj = memPoolAlloc(is_defer_func_pool); }
static basic_data * authBasicDataNew(void) { basic_data *temp; temp = memPoolAlloc(basic_data_pool); assert(temp != NULL); temp->username = NULL; temp->passwd = NULL; temp->auth_queue = NULL; return temp; }
static void authenticateDecodeNegotiateAuth(auth_user_request_t * auth_user_request, const char *proxy_auth) { dlink_node *node; assert(auth_user_request->auth_user == NULL); auth_user_request->auth_user = authenticateAuthUserNew("negotiate"); auth_user_request->auth_user->auth_type = AUTH_NEGOTIATE; auth_user_request->auth_user->scheme_data = memPoolAlloc(negotiate_user_pool); auth_user_request->scheme_data = memPoolAlloc(negotiate_request_pool); memset(auth_user_request->scheme_data, '\0', sizeof(negotiate_request_t)); /* lock for the auth_user_request link */ authenticateAuthUserLock(auth_user_request->auth_user); node = dlinkNodeNew(); dlinkAdd(auth_user_request, node, &auth_user_request->auth_user->requests); /* the helper does the rest, with data collected in * authenticateNegotiateAuthenticateUser */ debug(29, 9) ("authenticateDecodeNegotiateAuth: Negotiate authentication\n"); return; }
static auth_user_request_t * authenticateAuthUserRequestNew(void) { auth_user_request_t *temp_request; if (!auth_user_request_pool) auth_user_request_pool = memPoolCreate("Authenticate Request Data", sizeof(auth_user_request_t)); temp_request = memPoolAlloc(auth_user_request_pool); assert(temp_request != NULL); memset(temp_request, '\0', sizeof(auth_user_request_t)); return temp_request; }
static void lru_add(RemovalPolicy * policy, StoreEntry * entry, RemovalPolicyNode * node) { LruPolicyData *lru = policy->_data; LruNode *lru_node; assert(!node->data); node->data = lru_node = memPoolAlloc(lru_node_pool); dlinkAddTail(entry, &lru_node->node, &lru->list); lru->count += 1; if (!lru->type) lru->type = repl_guessType(entry, node); }
/* Write */ void storeAufsWrite(SwapDir * SD, storeIOState * sio, char *buf, size_t size, squid_off_t offset, FREE * free_func) { squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate; debug(79, 3) ("storeAufsWrite: dirno %d, fileno %08X, FD %d\n", sio->swap_dirn, sio->swap_filen, aiostate->fd); if (aiostate->fd < 0) { /* disk file not opened yet */ struct _queued_write *q; assert(aiostate->flags.opening); q = memPoolAlloc(aufs_qwrite_pool); q->buf = buf; q->size = size; q->offset = (off_t) offset; q->free_func = free_func; linklistPush(&(aiostate->pending_writes), q); return; } #if ASYNC_WRITE if (aiostate->flags.writing) { struct _queued_write *q; debug(79, 3) ("storeAufsWrite: queuing write\n"); q = memPoolAlloc(aufs_qwrite_pool); q->buf = buf; q->size = size; q->offset = (off_t) offset; q->free_func = free_func; linklistPush(&(aiostate->pending_writes), q); return; } aiostate->flags.writing = 1; aioWrite(aiostate->fd, (off_t) offset, buf, size, storeAufsWriteDone, sio, free_func, INDEX_OF_SD(SD)); statCounter.syscalls.disk.writes++; #else file_write(aiostate->fd, (off_t) offset, buf, size, storeAufsWriteDone, sio, free_func); /* file_write() increments syscalls.disk.writes */ #endif }
void * squidaio_xmalloc(int size) { void *p; MemPool *pool; if ((pool = squidaio_get_pool(size)) != NULL) { p = memPoolAlloc(pool); } else p = xmalloc(size); return p; }