自学教程：C++ xstrerror函数代码示例

const char *bfd_errmsg (bfd_error_type error_tag){#ifndef errno  extern int errno;#endif  if (error_tag == bfd_error_system_call)    return xstrerror (errno);  if (error_tag > bfd_error_invalid_error_code)    error_tag = bfd_error_invalid_error_code;	/* sanity check */  return _(bfd_errmsgs [error_tag]);}

// generate public/private key pair for digital signatures void genkeys (void){   if (open_crypt())  {    if (CryptGenKey (hProv, AT_SIGNATURE,       keylen<<16 | CRYPT_EXPORTABLE, &hKey))    {      // export as C array and binary      export_key (PUBLICKEYBLOB,  RSA_PUBLIC_H,    RSA_C_ARRAY);      export_key (PUBLICKEYBLOB,  RSA_PUBLIC_BIN,  RSA_BINARY);            export_key (PRIVATEKEYBLOB, RSA_PRIVATE_H,   RSA_C_ARRAY);      export_key (PRIVATEKEYBLOB, RSA_PRIVATE_BIN, RSA_BINARY);            close_key();    } else {      xstrerror ("CryptGenKey(%i)", keylen);    }    close_crypt();  } else {    xstrerror ("CryptAcquireContext()");  }}

static voidnetdbSaveState(void *foo){    Logfile *lf;    netdbEntry *n;    net_db_name *x;    struct timeval start = current_time;    int count = 0;    if (strcmp(Config.netdbFilename, "none") == 0)        return;    /*     * This was nicer when we were using stdio, but thanks to     * Solaris bugs, its a bad idea.  fopen can fail if more than     * 256 FDs are open.     */    /*     * unlink() is here because there is currently no way to make     * logfileOpen() use O_TRUNC.     */    unlink(Config.netdbFilename);    lf = logfileOpen(Config.netdbFilename, 4096, 0);    if (NULL == lf) {        debug(50, 1) ("netdbSaveState: %s: %s/n", Config.netdbFilename, xstrerror());        return;    }    hash_first(addr_table);    while ((n = (netdbEntry *) hash_next(addr_table))) {        if (n->pings_recv == 0)            continue;        logfilePrintf(lf, "%s %d %d %10.5f %10.5f %d %d",                      n->network,                      n->pings_sent,                      n->pings_recv,                      n->hops,                      n->rtt,                      (int) n->next_ping_time,                      (int) n->last_use_time);        for (x = n->hosts; x; x = x->next)            logfilePrintf(lf, " %s", hashKeyStr(&x->hash));        logfilePrintf(lf, "/n");        count++;#undef RBUF_SZ    }    logfileClose(lf);    getCurrentTime();    debug(38, 1) ("NETDB state saved; %d entries, %d msec/n",                  count, tvSubMsec(start, current_time));    eventAddIsh("netdbSaveState", netdbSaveState, NULL, 3600.0, 1);}

static voidwhoisReadReply(int fd, void *data){    WhoisState *p = data;    StoreEntry *entry = p->entry;    char *buf = memAllocate(MEM_4K_BUF);    MemObject *mem = entry->mem_obj;    int len;    statCounter.syscalls.sock.reads++;    len = FD_READ_METHOD(fd, buf, 4095);    buf[len] = '/0';    debug(75, 3) ("whoisReadReply: FD %d read %d bytes/n", fd, len);    debug(75, 5) ("{%s}/n", buf);    if (len > 0) {	if (0 == mem->inmem_hi) {	    http_reply *reply = mem->reply;	    storeBuffer(entry);	    httpReplySetHeaders(reply, HTTP_OK, "Gatewaying", "text/plain", -1, -1, -1);	    httpReplySwapOut(reply, entry);	}	fd_bytes(fd, len, FD_READ);	kb_incr(&statCounter.server.all.kbytes_in, len);	kb_incr(&statCounter.server.http.kbytes_in, len);	storeAppend(entry, buf, len);	storeBufferFlush(entry);	commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);    } else if (len < 0) {	debug(50, 2) ("whoisReadReply: FD %d: read failure: %s./n",	    fd, xstrerror());	if (ignoreErrno(errno)) {	    commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);	} else {	    ErrorState *err;	    err = errorCon(ERR_READ_ERROR, HTTP_BAD_GATEWAY, p->fwd->request);	    err->xerrno = errno;	    fwdFail(p->fwd, err);	    comm_close(fd);	}    } else {	storeTimestampsSet(entry);	storeBufferFlush(entry);	if (!EBIT_TEST(entry->flags, RELEASE_REQUEST))	    storeSetPublicKey(entry);	fwdComplete(p->fwd);	debug(75, 3) ("whoisReadReply: Done: %s/n", storeUrl(entry));	comm_close(fd);    }    memFree(buf, MEM_4K_BUF);}

/* Return 1 if the file is a directory, 0 if not, -1 on error. */int is_dir (const char *file){	struct stat file_stat;	if (is_url (file))		return 0;	if (stat (file, &file_stat) == -1) {		char *err = xstrerror (errno);		error ("Can't stat %s: %s", file, err);		free (err);		return -1;	}	return S_ISDIR(file_stat.st_mode) ? 1 : 0;}

// connect to servervoid client(args_t *p){  spp_ctx c;  int     term=0;    do  {    spp_init(&c, SPP_CLIENT);        // create socket    p->s=socket(p->ai_family, SOCK_STREAM, IPPROTO_TCP);    if (p->s!=SOCKET_ERROR)    {      printf ("[ connecting to %s/n", addr2ip(p));      if (connect (p->s, p->ai_addr, p->ai_addrlen)!=SOCKET_ERROR)      {        printf ("[ connected/n");        c.s=p->s;        printf ("[ performing key exchange/n");        if (spp_handshake(&c))        {          term = dispatch(&c);          printf ("[ closing connection/n");        } else xstrerror("");      } else {        xstrerror ("connect");      }      shutdown (p->s, SD_BOTH);      closesocket (p->s);    }    if (!term) {      Sleep (2000); // sleep for 2 seconds, then try again    }    spp_end(&c);  } while (!term);}

/* * Aborts with fatal message if write() returns something other * than its length argument. */static voidlogfileWriteWrapper(Logfile * lf, const void *buf, size_t len){    l_stdio_t *ll = (l_stdio_t *) lf->data;    size_t s;    s = FD_WRITE_METHOD(ll->fd, (char const *) buf, len);    fd_bytes(ll->fd, s, FD_WRITE);    if (s == len)	return;    if (!lf->flags.fatal)	return;    fatalf("logfileWrite (stdio): %s: %s/n", lf->path, xstrerror());}

storeIOState *storeUfsCreate(SwapDir * SD, StoreEntry * e, STFNCB * file_callback, STIOCB * callback, void *callback_data){    storeIOState *sio;    int fd;    int mode = (O_WRONLY | O_CREAT | O_TRUNC | O_BINARY);    char *path;    ufsinfo_t *ufsinfo = (ufsinfo_t *) SD->fsdata;    sfileno filn;    sdirno dirn;    /* Allocate a number */    dirn = SD->index;    filn = storeUfsDirMapBitAllocate(SD);    ufsinfo->suggest = filn + 1;    /* Shouldn't we handle a 'bitmap full' error here? */    path = storeUfsDirFullPath(SD, filn, NULL);    debug(79, 3) ("storeUfsCreate: fileno %08X/n", filn);    fd = file_open(path, mode);    if (fd < 0) {	debug(79, 1) ("storeUfsCreate: Failed to create %s (%s)/n", path, xstrerror());	return NULL;    }    debug(79, 3) ("storeUfsCreate: opened FD %d/n", fd);    CBDATA_INIT_TYPE_FREECB(storeIOState, storeUfsIOFreeEntry);    sio = cbdataAlloc(storeIOState);    sio->fsstate = memPoolAlloc(ufs_state_pool);    sio->swap_filen = filn;    sio->swap_dirn = dirn;    sio->mode = mode;    sio->callback = callback;    sio->callback_data = callback_data;    cbdataLock(callback_data);    sio->e = (StoreEntry *) e;    ((ufsstate_t *) (sio->fsstate))->fd = fd;    ((ufsstate_t *) (sio->fsstate))->flags.writing = 0;    ((ufsstate_t *) (sio->fsstate))->flags.reading = 0;    ((ufsstate_t *) (sio->fsstate))->flags.close_request = 0;    store_open_disk_fd++;    ufsinfo->open_files++;    /* now insert into the replacement policy */    storeUfsDirReplAdd(SD, e);    return sio;}

voida_file_read(async_queue_t * q, int fd, void *buf, int req_len, off_t offset,    DRCB * callback, void *data){    int slot;    async_queue_entry_t *qe;    assert(q->aq_state == AQ_STATE_SETUP);    assert(offset >= 0);    /* Find a free slot */    slot = a_file_findslot(q);    if (slot < 0) {	/* No free slot? Callback error, and return */	debug(79, 1) ("WARNING: out of aiocb slots!/n");	/* fall back to blocking method */	file_read(fd, buf, req_len, offset, callback, data);	return;    }    /* Mark slot as ours */    qe = &q->aq_queue[slot];    qe->aq_e_state = AQ_ENTRY_USED;    qe->aq_e_callback.read = callback;    qe->aq_e_callback_data = data;    qe->aq_e_type = AQ_ENTRY_READ;    qe->aq_e_free = NULL;    qe->aq_e_buf = buf;    qe->aq_e_fd = fd;    qe->aq_e_aiocb.aio_fildes = fd;    qe->aq_e_aiocb.aio_nbytes = req_len;    qe->aq_e_aiocb.aio_offset = offset;    qe->aq_e_aiocb.aio_buf = buf;    /* Account */    q->aq_numpending++;    /* Lock */    cbdataLock(data);    /* Initiate aio */    if (aio_read(&qe->aq_e_aiocb) < 0) {	debug(79, 1) ("WARNING: aio_read() returned error: %s/n", xstrerror());	/* fall back to blocking method */	file_read(fd, buf, req_len, offset, callback, data);    }}

// Resolve host, create socket and event handle associated with it BOOL open_tcp (void){  struct addrinfo *list, *e;  struct addrinfo hints;  BOOL            bStatus=FALSE;  WSADATA         wsa;  int             on=1;    WSAStartup (MAKEWORD (2, 0), &wsa);    ZeroMemory (&hints, sizeof (hints));  hints.ai_family   = args.ai_family;  hints.ai_socktype = SOCK_STREAM;  hints.ai_protocol = IPPROTO_TCP;    // get all resolvable addresses for this machine name  if (getaddrinfo (args.address, args.port, &hints, &list) == 0)   {    for (e=list; e!=NULL; e=e->ai_next)     {      if (args.ai_family==AF_INET) {        memcpy (&sin_ipv4, e->ai_addr, e->ai_addrlen);        ai_addr     = (SOCKADDR*)&sin_ipv4;              } else {        memcpy (&sin_ipv6, e->ai_addr, e->ai_addrlen);        ai_addr     = (SOCKADDR*)&sin_ipv6;      }      ai_addrlen = e->ai_addrlen;      // create socket      s=socket (args.ai_family, SOCK_STREAM, IPPROTO_TCP);      evt[sck_evt = evt_cnt++] = WSACreateEvent();      if (s!=SOCKET_ERROR) {        // ensure we can reuse same port later        setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof (on));        bStatus=TRUE;      }      break;    }    freeaddrinfo (list);  } else {    xstrerror ("getaddrinfo(%s)", args.address);  }  return bStatus;}

static struct value *sys_read_file(struct info *info, struct value *n) {    assert(n->tag == V_STRING);    char *str = NULL;    str = xread_file(n->string->str);    if (str == NULL) {        char error_buf[1024];        const char *errmsg;        errmsg = xstrerror(errno, error_buf, sizeof(error_buf));        struct value *exn = make_exn_value(ref(info),             "reading file %s failed:", n->string->str);        exn_printf_line(exn, "%s", errmsg);        return exn;    }    struct value *v = make_value(V_STRING, ref(info));    v->string = make_string(str);    return v;}

static voidlogfile_mod_udp_write(Logfile * lf, const char *buf, size_t len){    l_udp_t *ll = (l_udp_t *) lf->data;    ssize_t s;    s = write(ll->fd, (char const *) buf, len);    fd_bytes(ll->fd, s, FD_WRITE);#if 0    if (s < 0) {        debug(1, 1) ("logfile (udp): got errno %d (%s)/n", errno, xstrerror());    }    if (s != len) {        debug(1, 1) ("logfile (udp): len %d, wrote %d/n", len, s);    }#endif    /* We don't worry about network errors for now */}

static intdo_comm_select(int msec){    int num, saved_errno;    struct timeval tv;    fd_set readfds;    fd_set writefds;    fd_set errfds;    int fd;    if (nreadfds + nwritefds == 0) {	assert(shutting_down);	return COMM_SHUTDOWN;    }    memcpy(&readfds, &global_readfds, sizeof(fd_set));    memcpy(&writefds, &global_writefds, sizeof(fd_set));    memcpy(&errfds, &global_writefds, sizeof(fd_set));    tv.tv_sec = msec / 1000;    tv.tv_usec = (msec % 1000) * 1000;    statCounter.syscalls.selects++;    num = select(Biggest_FD + 1, &readfds, &writefds, &errfds, &tv);    saved_errno = errno;    getCurrentTime();    debug(5, 5) ("do_comm_select: %d fds ready/n", num);    if (num < 0) {	if (ignoreErrno(saved_errno))	    return COMM_OK;	debug(5, 1) ("comm_select: select failure: %s/n", xstrerror());	return COMM_ERROR;    }    statHistCount(&statCounter.select_fds_hist, num);    if (num == 0)	return COMM_TIMEOUT;    for (fd = 0; fd <= Biggest_FD; fd++) {	int read_event = FD_ISSET(fd, &readfds);	int write_event = FD_ISSET(fd, &writefds) || FD_ISSET(fd, &errfds);	if (read_event || write_event)	    comm_call_handlers(fd, read_event, write_event);    }    return COMM_OK;}

/* Read from FD */static voiddiskHandleRead(int fd, void *data){    dread_ctrl *ctrl_dat = data;    fde *F = &fd_table[fd];    int len;    int rc = DISK_OK;    /*     * FD < 0 indicates premature close; we just have to free     * the state data.     */    if (fd < 0) {	memFree(ctrl_dat, MEM_DREAD_CTRL);	return;    }    if (F->disk.offset != ctrl_dat->file_offset) {	debug(6, 3) ("diskHandleRead: FD %d seeking to offset %d/n",	    fd, (int) ctrl_dat->file_offset);	lseek(fd, ctrl_dat->file_offset, SEEK_SET);	/* XXX ignore return? */	statCounter.syscalls.disk.seeks++;	F->disk.offset = ctrl_dat->file_offset;    }    errno = 0;    len = FD_READ_METHOD(fd, ctrl_dat->buf, ctrl_dat->req_len);    if (len > 0)	F->disk.offset += len;    statCounter.syscalls.disk.reads++;    fd_bytes(fd, len, FD_READ);    if (len < 0) {	if (ignoreErrno(errno)) {	    commSetSelect(fd, COMM_SELECT_READ, diskHandleRead, ctrl_dat, 0);	    return;	}	debug(50, 1) ("diskHandleRead: FD %d: %s/n", fd, xstrerror());	len = 0;	rc = DISK_ERROR;    } else if (len == 0) {	rc = DISK_EOF;    }    if (cbdataValid(ctrl_dat->client_data))	ctrl_dat->handler(fd, ctrl_dat->buf, len, rc, ctrl_dat->client_data);    cbdataUnlock(ctrl_dat->client_data);    memFree(ctrl_dat, MEM_DREAD_CTRL);}

static void *sndfile_open (const char *file){	int fd;	struct sndfile_data *data;	data = (struct sndfile_data *)xmalloc (sizeof(struct sndfile_data));	decoder_error_init (&data->error);	memset (&data->snd_info, 0, sizeof(data->snd_info));	data->timing_broken = false;	fd = open (file, O_RDONLY);	if (fd == -1) {		char *err = xstrerror (errno);		decoder_error (&data->error, ERROR_FATAL, 0,		               "Can't open file: %s", err);		free (err);		return data;	}	/* sf_open_fd() close()s 'fd' on error and in sf_close(). */	data->sndfile = sf_open_fd (fd, SFM_READ, &data->snd_info, SF_TRUE);	if (!data->sndfile) {		/* FIXME: sf_strerror is not thread safe with NULL argument */		decoder_error (&data->error, ERROR_FATAL, 0,				"Can't open file: %s", sf_strerror(NULL));		return data;	}	/* If the timing is broken, sndfile only decodes up to the broken value. */	data->timing_broken = is_timing_broken (fd, data);	if (data->timing_broken) {		decoder_error (&data->error, ERROR_FATAL, 0,		               "File too large for audio format!");		return data;	}	debug ("Opened file %s", file);	debug ("Channels: %d", data->snd_info.channels);	debug ("Format: %08X", data->snd_info.format);	debug ("Sample rate: %d", data->snd_info.samplerate);	return data;}

static void m3u8Event(void *args){    if(!is_m3u8_prefetch_alive()){        debug(207,3)("m3u8_prefetch dont run,now starting it!/n");        enter_suid();        int cid = fork();        if (cid == 0) {            int ret = execl("/usr/local/squid/bin/m3u8_prefetch", "m3u8_prefetch","15101",(char *)0);            if (ret < 0) {                debug(207,3)("(m3u8) --> execl error : %s/n",xstrerror());            }            exit(-1);        }        leave_suid();    }    eventAdd("m3u8Event", m3u8Event, NULL, 30, 0);	}

static intdo_comm_select(int msec){    int num;    int i;    if (nfds == 0) {	assert(shutting_down);	return COMM_SHUTDOWN;    }    statCounter.syscalls.selects++;    num = poll(pfds, nfds, msec);    if (num < 0) {	getCurrentTime();	if (ignoreErrno(errno))	    return COMM_OK;	debug(5, 1) ("comm_select: poll failure: %s/n", xstrerror());	return COMM_ERROR;    }    statHistCount(&statCounter.select_fds_hist, num);    if (num == 0)	return COMM_TIMEOUT;    for (i = nfds - 1; num > 0 && i >= 0; i--) {	struct pollfd *pfd = &pfds[i];	short read_event, write_event;	if (!pfd->revents)	    continue;	read_event = pfd->revents & (POLLRDNORM | POLLIN | POLLHUP | POLLERR);	write_event = pfd->revents & (POLLWRNORM | POLLOUT | POLLHUP | POLLERR);	pfd->revents = 0;	comm_call_handlers(pfd->fd, read_event, write_event);	num--;    }    return COMM_OK;}

static voidpfatal_pexecute (const char *errmsg_fmt, const char *errmsg_arg){  if (errmsg_arg)    {      int save_errno = errno;      /* Space for trailing '/0' is in %s.  */      char *msg = (char *) malloc (strlen (errmsg_fmt) + strlen (errmsg_arg));      sprintf (msg, errmsg_fmt, errmsg_arg);      errmsg_fmt = msg;      errno = save_errno;    }  fprintf (stderr,"%s: %s: %s/n", progname, errmsg_fmt, xstrerror (errno));  delete_out_files ();  exit (1);}

voidstoreDiskdRead(SwapDir * SD, storeIOState * sio, char *buf, size_t size, squid_off_t offset, STRCB * callback, void *callback_data){    int x;    int shm_offset;    char *rbuf;    diskdstate_t *diskdstate = sio->fsstate;    debug(79, 3) ("storeDiskdRead: dirno %d, fileno %08X/n", sio->swap_dirn, sio->swap_filen);    if (diskdstate->flags.close_request) {	debug(79, 2) ("storeDiskRead: closing, so ignore!/n");	return;    }    if (!cbdataValid(sio))	return;    if (diskdstate->flags.reading) {	debug(79, 1) ("storeDiskdRead: already reading!/n");	return;    }    assert(sio->read.callback == NULL);    assert(sio->read.callback_data == NULL);    sio->read.callback = callback;    sio->read.callback_data = callback_data;    diskdstate->read_buf = buf;	/* the one passed from above */    cbdataLock(sio->read.callback_data);    sio->offset = offset;    diskdstate->flags.reading = 1;    rbuf = storeDiskdShmGet(SD, &shm_offset);    assert(rbuf);    x = storeDiskdSend(_MQD_READ,	SD,	diskdstate->id,	sio,	size,	(off_t) offset,	shm_offset);    if (x < 0) {	debug(79, 1) ("storeDiskdSend READ: %s/n", xstrerror());	storeDiskdShmPut(SD, shm_offset);	storeDiskdIOCallback(sio, DISK_ERROR);    }    diskd_stats.read.ops++;}

static voidwhoisReadReply(int fd, void *data){    WhoisState *p = data;    StoreEntry *entry = p->entry;    char *buf = memAllocate(MEM_4K_BUF);    MemObject *mem = entry->mem_obj;    int len;    statCounter.syscalls.sock.reads++;    len = FD_READ_METHOD(fd, buf, 4095);    buf[len] = '/0';    debug(75, 3) ("whoisReadReply: FD %d read %d bytes/n", fd, len);    debug(75, 5) ("{%s}/n", buf);    if (len > 0) {	if (0 == mem->inmem_hi)	    mem->reply->sline.status = HTTP_OK;	fd_bytes(fd, len, FD_READ);	kb_incr(&statCounter.server.all.kbytes_in, len);	kb_incr(&statCounter.server.http.kbytes_in, len);	storeAppend(entry, buf, len);	commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);    } else if (len < 0) {	debug(50, 2) ("whoisReadReply: FD %d: read failure: %s./n",	    fd, xstrerror());	if (ignoreErrno(errno)) {	    commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);	} else if (mem->inmem_hi == 0) {	    ErrorState *err;	    err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);	    err->xerrno = errno;	    fwdFail(p->fwd, err);	    comm_close(fd);	} else {	    comm_close(fd);	}    } else {	fwdComplete(p->fwd);	debug(75, 3) ("whoisReadReply: Done: %s/n", storeUrl(entry));	comm_close(fd);    }    memFree(buf, MEM_4K_BUF);}

/* * opens a disk file specified by 'path'.  This function always * blocks!  There is no callback. */intfile_open(const char *path, int mode){    int fd;    if (FILE_MODE(mode) == O_WRONLY)	mode |= O_APPEND;    errno = 0;    fd = open(path, mode, 0644);    statCounter.syscalls.disk.opens++;    if (fd < 0) {	debug(50, 3) ("file_open: error opening file %s: %s/n", path,	    xstrerror());	fd = DISK_ERROR;    } else {	debug(6, 5) ("file_open: FD %d/n", fd);	commSetCloseOnExec(fd);	fd_open(fd, FD_FILE, path);    }    return fd;}

struct str *listing(struct post *post, const char *fname){	char path[FILENAME_MAX];	struct str *in;	snprintf(path, FILENAME_MAX, "%s/posts/%d/%s",		 str_cstr(config.data_dir), post->id, fname);	in = file_cache_get_cb(path, post->preview ? NULL : revalidate_post,			       post);	if (IS_ERR(in))		goto err;	return listing_str(in);err:	snprintf(path, FILENAME_MAX, "Failed to read in listing '%d/%s': %s",		 post->id, fname, xstrerror(PTR_ERR(in)));	return STR_DUP(path);}

char *read_file (const location &loc, const char *path){  FILE *f_in = fopen (path, "r");  if (!f_in)    fail_formatted (loc, "unable to open file: %s", path);  /* Read content, allocating FIXME.  */  char *result = NULL;  size_t total_sz = 0;  size_t alloc_sz = 0;  char buf[4096];  size_t iter_sz_in;  while ( (iter_sz_in = fread (buf, 1, sizeof (buf), f_in)) )    {      gcc_assert (alloc_sz >= total_sz);      size_t old_total_sz = total_sz;      total_sz += iter_sz_in;      /* Allow 1 extra byte for 0-termination.  */      if (alloc_sz < (total_sz + 1))	{	  size_t new_alloc_sz = alloc_sz ? alloc_sz * 2: total_sz + 1;	  result = (char *)xrealloc (result, new_alloc_sz);	  alloc_sz = new_alloc_sz;	}      memcpy (result + old_total_sz, buf, iter_sz_in);    }  if (!feof (f_in))    fail_formatted (loc, "error reading from %s: %s", path,		    xstrerror (errno));  fclose (f_in);  /* 0-terminate the buffer.  */  gcc_assert (total_sz < alloc_sz);  result[total_sz] = '/0';  return result;}

voidas_perror (const char *gripe,		/* Unpunctuated error theme.  */	   const char *filename){  const char *errtxt;  int saved_errno = errno;  as_show_where ();  fprintf (stderr, gripe, filename);  errno = saved_errno;#ifdef BFD_ASSEMBLER  errtxt = bfd_errmsg (bfd_get_error ());#else  errtxt = xstrerror (errno);#endif  fprintf (stderr, ": %s/n", errtxt);  errno = 0;#ifdef BFD_ASSEMBLER  bfd_set_error (bfd_error_no_error);#endif}

voidstoreDiskdClose(SwapDir * SD, storeIOState * sio){    int x;    diskdstate_t *diskdstate = sio->fsstate;    debug(79, 3) ("storeDiskdClose: dirno %d, fileno %08X/n", SD->index,	sio->swap_filen);    diskdstate->flags.close_request = 1;    x = storeDiskdSend(_MQD_CLOSE,	SD,	diskdstate->id,	sio,	0,	0,	-1);    if (x < 0) {	debug(79, 1) ("storeDiskdSend CLOSE: %s/n", xstrerror());	storeDiskdIOCallback(sio, DISK_ERROR);    }    diskd_stats.close.ops++;}

static void  errorTryLoadText(MemBuf * text, char *path){	int fd;	struct stat sb;//	char *text = NULL;	//snprintf(path, sizeof(path), "%s/%s", dir, page_name);#ifdef _SQUID_MSWIN_	fd = open(path, O_RDONLY | O_BINARY);#else	fd = open(path, O_RDONLY | O_TEXT);#endif	if (fd < 0 || fstat(fd, &sb) < 0)	{		debug(115, 0) ("mod_customized_server_side_error_page errorTryLoadText: '%s': %s/n", path, xstrerror());		if (fd >= 0)			file_close(fd);		//return NULL;		memBufInit(text, 1*sizeof(char), 1*sizeof(char));		memBufPrintf(text, "%s", "");	}	else	{		memBufInit(text, (size_t)sb.st_size+2+1, (size_t)sb.st_size+2+1);		if (read(fd, text->buf, (int) sb.st_size) != sb.st_size)		{			debug(115,0) ("mod_customized_server_side_error_page errorTryLoadText: failed to fully read: '%s': %s/n",					path, xstrerror());			memBufClean(text);		}		text->size += sb.st_size;		text->buf[text->size] = '/0';		debug(115,4)("mod_customized_server_side_error_page errorTryLoadText: the path is: %s point before end and text is: %s...../n", path,text->buf);		close(fd);	}#ifndef CC_FRAMEWORK	if (NULL != text->buf && strstr(text->buf, "%s") == NULL)		memBufAppend(text,"%S", strlen("%S"));	/* add signature */#endif }