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

static voidgetfovimg(void)			/* load foveal sampled image */{	char	combuf[PATH_MAX];	FILE	*fp;	int	x, y;						/* compute image size */	fvxr = sqrt(ourview.hn2)/FOVDIA + 0.5;	if (fvxr < 2) fvxr = 2;	fvyr = sqrt(ourview.vn2)/FOVDIA + 0.5;	if (fvyr < 2) fvyr = 2;	if (!(inpres.rt & YMAJOR)) {		/* picture is rotated? */		y = fvyr;		fvyr = fvxr;		fvxr = y;	}	if ((fovimg = (COLOR *)malloc(fvxr*fvyr*sizeof(COLOR))) == NULL)		syserror("malloc");	sprintf(combuf, "pfilt -1 -b -pa 0 -x %d -y %d /"%s/"", fvxr, fvyr, infn);	if ((fp = popen(combuf, "r")) == NULL)		syserror("popen");	getheader(fp, NULL, NULL);	/* skip header */	if (fgetresolu(&x, &y, fp) < 0 || (x != fvxr) | (y != fvyr))		goto readerr;	for (y = 0; y < fvyr; y++)		if (freadscan(fovscan(y), fvxr, fp) < 0)			goto readerr;	pclose(fp);	return;readerr:	fprintf(stderr, "%s: error reading from pfilt process in fovimage/n",			progname);	exit(1);}

intsys_get_robust_list(struct tcb *tcp){	if (entering(tcp)) {		tprintf("%ld, ", (long) (pid_t) tcp->u_arg[0]);	} else {		void *addr;		size_t len;		if (syserror(tcp) ||		    !tcp->u_arg[1] ||		    umove(tcp, tcp->u_arg[1], &addr) < 0) {			tprintf("%#lx, ", tcp->u_arg[1]);		} else {			tprintf("[%p], ", addr);		}		if (syserror(tcp) ||		    !tcp->u_arg[2] ||		    umove(tcp, tcp->u_arg[2], &len) < 0) {			tprintf("%#lx", tcp->u_arg[2]);		} else {			tprintf("[%lu]", (unsigned long) len);		}	}	return 0;}

/* Check if filename is a valid FIFO pipe. If not create it. * Returns 0 on success, -1 on error. */int checkfifo(const char* filename) {    struct stat fstat;    /* Check if file exists: if not, create the FIFO. */    if (access(filename, F_OK) < 0) {        if (mkfifo(filename,                S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH) < 0) {            syserror("Cannot create FIFO pipe.");            return -1;        }        return 0;    }    /* We must be able to read and write the file. (only one direction is     * necessary in croutonwebsocket, but croutonclip needs the other direction)     */    if (access(filename, R_OK|W_OK) < 0) {        error("%s exists, but not readable and writable.",                filename);        return -1;    }    if (stat(filename, &fstat) < 0) {        syserror("Cannot stat FIFO pipe.");        return -1;    }    if (!S_ISFIFO(fstat.st_mode)) {        error("%s exists, but is not a FIFO pipe.", filename);        return -1;    }    return 0;}

int find_nacl(int conn){    char argbuf[70], outbuf[256];    char* cut;    int idx = 0, c;    if ((c = read(conn, argbuf, sizeof(argbuf)-1)) < 0) {       syserror("Failed to read arguments");       return -1;    }    argbuf[c] = 0;    cut = strchr(argbuf, ' ');    if (!cut) {        error("No ' ' in findnacl arguments: %s.", argbuf);        return -1;    }    *cut = 0;    char *cmd = "croutonfindnacl";    char* args[] = {cmd, argbuf, cut + 1, NULL};    c = popen2(cmd, args, NULL, 0, outbuf, sizeof(outbuf)-1);    if (c <= 0) {        error("Error running helper");        return -1;    }    outbuf[c] = 0;    /* Parse PID:file output */    cut = strchr(outbuf, ':');    if (!cut) {        error("No ':' in helper reply: %s.", outbuf);        return -1;    }    *cut = 0;    char* endptr;    long pid = strtol(outbuf, &endptr, 10);    if(outbuf == endptr || *endptr != '/0') {        error("Invalid pid: %s", outbuf);        return -1;    }    char* file = cut+1;    int ret = 0;    int fd = -1;    if (pid > 0) {        if ((fd = open(file, O_RDWR)) < 0)            syserror("Cannot open file %s", file);    }    if (send_pid_fd(conn, pid, fd) < 0) {        syserror("FD-passing failed.");        ret = -1;    }    close(fd);    return ret;}

void TEXT_init(TEXT_t *l, char *filename, char *mode){  struct stat buf;  if ((l->filename = strdup(filename))==NULL) syserror(errno,"strdup");  if ((l->file=fopen(l->filename, mode))==NULL) syserror(errno,l->filename);  if (SETVBUF(l->file,NULL,_IOFBF,BUFSIZ>TEXT_BUFFER?BUFSIZ:TEXT_BUFFER)!=0) syserror(errno,"setvbuf");  if (stat(l->filename,&buf)==-1) syserror(errno,l->filename);  l->filesize=buf.st_size;}

intproc_ioctl(struct tcb *tcp, int code, int arg){	int val;	struct procfs_status status;	if (entering(tcp))		return 0;	switch (code) {	case PIOCSTATUS:	case PIOCWAIT:		if (arg == 0)			tprintf(", NULL");		else if (syserror(tcp))			tprintf(", %x", arg);		else if (umove(tcp, arg, &status) < 0)			tprintf(", {...}");		else {			tprintf(", {state=%d, flags=", status.state);			printflags(proc_status_flags, status.flags, "PF_???");			tprintf(", events=");			printflags(proc_status_why, status.events, "S_???");			tprintf(", why=");			printxval(proc_status_why, status.why, "S_???");			tprintf(", val=%lu}", status.val);		}		return 1;	case PIOCBIS:		tprintf(", ");		printflags(proc_status_why, arg, "S_???");		return 1;		return 1;	case PIOCSFL:		tprintf(", ");		printflags(proc_status_flags, arg, "PF_???");		return 1;	case PIOCGFL:		if (syserror(tcp))			tprintf(", %#x", arg);		else if (umove(tcp, arg, &val) < 0)			tprintf(", {...}");		else {			tprintf(", [");			printflags(proc_status_flags, val, "PF_???");			tprintf("]");		}		return 1;	default:		/* ad naseum */		return 0;	}}

void LMP_init(LMP_t *l, char *filename, char *mode){  struct stat buf;  struct tm   *ft;  if ((l->filename = strdup(filename))==NULL) syserror(errno,"strdup");  if ((l->file=fopen(l->filename, mode))==NULL) syserror(errno,l->filename);  if (SETVBUF(l->file,NULL,_IOFBF,BUFSIZ>MYBUFSIZE?BUFSIZ:MYBUFSIZE)!=0) syserror(errno,"setvbuf");  if (stat(l->filename,&buf)==-1) syserror(errno,l->filename);  l->filesize=buf.st_size;  ft=localtime(&buf.st_mtime);  l->year=ft->tm_year;}

intNotifyCream(char *buffer, creamConnection_t *connection){	int      retcod;	struct   pollfd fds[2];	if (connection->creamfilter == NULL) return -1;    	fds[0].fd = connection->socket_fd;	fds[0].events = ( POLLOUT | POLLPRI | POLLERR | POLLHUP | POLLNVAL ) ;    	if(!connection->creamisconn){		return -1;	}		retcod = poll(fds, 1, bfunctions_poll_timeout);         	if (retcod < 0) {		free_cream_connection(connection);		do_log(debuglogfile, debug, 1, "Fatal Error:Poll error in NotifyCream errno:%d/n",errno);		sysfatal("Poll error in NotifyCream: %r");	} else if ( retcod == 0 ) {		do_log(debuglogfile, debug, 1, "Error:poll() timeout in NotifyCream/n");		syserror("poll() timeout in NotifyCream: %r");		return -1;	} else if ( retcod > 0 ) {		if (( fds[0].revents & ( POLLERR | POLLNVAL | POLLHUP) )){			switch (fds[0].revents){			case POLLNVAL:				do_log(debuglogfile, debug, 1, "Error:poll() file descriptor error in NotifyCream/n");				syserror("poll() file descriptor error in NotifyCream: %r");				return -1;			case POLLHUP:				do_log(debuglogfile, debug, 1, "Connection closed in NotifyCream/n");				syserror("Connection closed in NotifyCream: %r");				return -1;			case POLLERR:				do_log(debuglogfile, debug, 1, "Error:poll() POLLERR in NotifyCream/n");				syserror("poll() POLLERR in NotifyCream: %r");				return -1;			}		} else {			Writeline(connection->socket_fd, buffer, strlen(buffer));			do_log(debuglogfile, debug, 1, "Sent for Cream:%s",buffer);		} 	}       	return 0;}

intscsi_ioctl(struct tcb *tcp, const unsigned int code, const long arg){	uint32_t iid;	if (SG_IO != code)		return RVAL_DECODED;	if (entering(tcp)) {		tprints(", ");		if (!arg || umove(tcp, arg, &iid) < 0) {			printaddr(arg);			return RVAL_DECODED | 1;		} else {			return print_sg_io_req(tcp, iid, arg);		}	} else {		if (!syserror(tcp)) {			if (umove(tcp, arg, &iid) < 0)				tprints(", ???");			else				print_sg_io_res(tcp, iid, arg);		}		tprintf("}");		return RVAL_DECODED | 1;	}}

static intdo_adjtimex(struct tcb *tcp, long addr){	if (addr == 0)		tprints("NULL");	else if (syserror(tcp) || !verbose(tcp))		tprintf("%#lx", addr);	else if (tprint_timex(tcp, addr) < 0)		tprints("{...}");	if (syserror(tcp))		return 0;	tcp->auxstr = xlookup(adjtimex_state, tcp->u_rval);	if (tcp->auxstr)		return RVAL_STR;	return 0;}

/** * Sends an HB_RESP in response to an HB_REQ */void send_hb_response(const struct sockaddr_in *src, int response){    unsigned char *packet;    struct uftp_h *header;    struct hb_resp_h *hbresp;    int meslen;    packet = calloc(sizeof(struct uftp_h) + sizeof(struct hb_resp_h), 1);    if (packet == NULL) {        syserror(0, 0, "calloc failed!");        exit(1);    }    header = (struct uftp_h *)packet;    hbresp = (struct hb_resp_h *)(packet + sizeof(struct uftp_h));    header->uftp_id = UFTP_VER_NUM;    header->func = HB_RESP;    header->blsize = ntohs(sizeof(struct hb_resp_h));    hbresp->func = HB_RESP;    hbresp->authenticated = response;    if (response == HB_AUTH_CHALLENGE) {        hbresp->nonce = htonl(down_nonce);    }    meslen = sizeof(struct uftp_h) + sizeof(struct hb_resp_h);    if (nb_sendto(listener, packet, meslen, 0, (struct sockaddr *)src,                  sizeof(struct sockaddr_in)) == SOCKET_ERROR) {        sockerror(0, 0, "Error sending HB_RESP");    } else {        log(0, 0, "Sent HB_RESP to %s:%d", inet_ntoa(src->sin_addr),                                           ntohs(src->sin_port));    }    free(packet);}

int sys_shmat(struct tcb *tcp){	if (exiting(tcp)) {		tprintf("%lu", tcp->u_arg[0]);		if (indirect_ipccall(tcp)) {			tprintf(", %#lx", tcp->u_arg[3]);			tprints(", ");			printflags(shm_flags, tcp->u_arg[1], "SHM_???");		} else {			tprintf(", %#lx", tcp->u_arg[1]);			tprints(", ");			printflags(shm_flags, tcp->u_arg[2], "SHM_???");		}		if (syserror(tcp))			return 0;		if (indirect_ipccall(tcp)) {			unsigned long raddr;			if (umove(tcp, tcp->u_arg[2], &raddr) < 0)				return RVAL_NONE;			tcp->u_rval = raddr;		}		return RVAL_HEX;	}	return 0;}

static intdecode_sockname(struct tcb *tcp){	int ulen, rlen;	if (entering(tcp)) {		printfd(tcp, tcp->u_arg[0]);		tprints(", ");		if (fetch_socklen(tcp, &ulen, tcp->u_arg[1], tcp->u_arg[2])) {			set_tcb_priv_ulong(tcp, ulen);			return 0;		} else {			printaddr(tcp->u_arg[1]);			tprints(", ");			printaddr(tcp->u_arg[2]);			return RVAL_DECODED;		}	}	ulen = get_tcb_priv_ulong(tcp);	if (syserror(tcp) || umove(tcp, tcp->u_arg[2], &rlen) < 0) {		printaddr(tcp->u_arg[1]);		tprintf(", [%d]", ulen);	} else {		decode_sockaddr(tcp, tcp->u_arg[1], ulen > rlen ? rlen : ulen);		if (ulen != rlen)			tprintf(", [%d->%d]", ulen, rlen);		else			tprintf(", [%d]", rlen);	}	return RVAL_DECODED;}

voidprintrusage(struct tcb *tcp, long addr){	struct rusage ru;	if (!addr)		tprints("NULL");	else if (syserror(tcp) || !verbose(tcp))		tprintf("%#lx", addr);	else if (umove(tcp, addr, &ru) < 0)		tprints("{...}");	else if (!abbrev(tcp)) {		tprintf("{ru_utime={%lu, %lu}, ru_stime={%lu, %lu}, ",			(long) ru.ru_utime.tv_sec, (long) ru.ru_utime.tv_usec,			(long) ru.ru_stime.tv_sec, (long) ru.ru_stime.tv_usec);		tprintf("ru_maxrss=%lu, ru_ixrss=%lu, ",			ru.ru_maxrss, ru.ru_ixrss);		tprintf("ru_idrss=%lu, ru_isrss=%lu, ",			ru.ru_idrss, ru.ru_isrss);		tprintf("ru_minflt=%lu, ru_majflt=%lu, ru_nswap=%lu, ",			ru.ru_minflt, ru.ru_majflt, ru.ru_nswap);		tprintf("ru_inblock=%lu, ru_oublock=%lu, ",			ru.ru_inblock, ru.ru_oublock);		tprintf("ru_msgsnd=%lu, ru_msgrcv=%lu, ",			ru.ru_msgsnd, ru.ru_msgrcv);		tprintf("ru_nsignals=%lu, ru_nvcsw=%lu, ru_nivcsw=%lu}",			ru.ru_nsignals, ru.ru_nvcsw, ru.ru_nivcsw);	}	else {		tprintf("{ru_utime={%lu, %lu}, ru_stime={%lu, %lu}, ...}",			(long) ru.ru_utime.tv_sec, (long) ru.ru_utime.tv_usec,			(long) ru.ru_stime.tv_sec, (long) ru.ru_stime.tv_usec);	}}

/** * Send out DONE messages specifiying active clients that haven't yet responded. * Returns 1 on success, 0 on fail */int send_done(const struct finfo_t *finfo, int attempt, int pass, int section){    unsigned char *buf;    struct uftp_h *header;    struct done_h *done;    uint32_t *addrlist;    int rval;    buf = calloc(mtu, 1);     if (buf == NULL) {        syserror(0, 0, "calloc failed!");        exit(1);    }    header = (struct uftp_h *)buf;    done = (struct done_h *)(buf + sizeof(struct uftp_h));    addrlist = (uint32_t *)((char *)done + sizeof(struct done_h));    set_uftp_header(header, DONE, finfo, &receive_dest);    done->func = DONE;    done->file_id = htons(finfo->file_id);    done->pass = pass;    done->section = htons(section);    rval = send_multiple(finfo, buf, DONE, attempt, addrlist, DEST_STATUS,            &done->destcount, (keytype != KEY_NONE), &receive_dest, 0);    free(buf);    return rval;}

intsys_rt_sigprocmask(struct tcb *tcp){	sigset_t sigset;	/* Note: arg[3] is the length of the sigset. */	if (entering(tcp)) {		printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");		tprints(", ");		if (!tcp->u_arg[1])			tprints("NULL, ");		else if (copy_sigset_len(tcp, tcp->u_arg[1], &sigset, tcp->u_arg[3]) < 0)			tprintf("%#lx, ", tcp->u_arg[1]);		else {			printsigmask(&sigset, 1);			tprints(", ");		}	}	else {		if (!tcp->u_arg[2])			tprints("NULL");		else if (syserror(tcp))			tprintf("%#lx", tcp->u_arg[2]);		else if (copy_sigset_len(tcp, tcp->u_arg[2], &sigset, tcp->u_arg[3]) < 0)			tprints("[?]");		else			printsigmask(&sigset, 1);		tprintf(", %lu", tcp->u_arg[3]);	}	return 0;}

/** * Send out DONE_CONF messages specifiying all completed clients. * Returns 1 on success, 0 on fail */int send_doneconf(const struct finfo_t *finfo, int attempt){    unsigned char *buf;    struct uftp_h *header;    struct doneconf_h *doneconf;    uint32_t *addrlist;    int rval;    if (finfo->file_id != 0) {        return 1;    }    buf = calloc(mtu, 1);     if (buf == NULL) {        syserror(0, 0, "calloc failed!");        exit(1);    }    header = (struct uftp_h *)buf;    doneconf = (struct doneconf_h *)(buf + sizeof(struct uftp_h));    addrlist = (uint32_t *)((char *)doneconf + sizeof(struct doneconf_h));    set_uftp_header(header, DONE_CONF, finfo, &receive_dest);    doneconf->func = DONE_CONF;    doneconf->file_id = htons(finfo->file_id);    rval = send_multiple(finfo, buf, DONE_CONF, attempt, addrlist, DEST_DONE,            &doneconf->destcount, (keytype != KEY_NONE), &receive_dest, 0);    free(buf);    return rval;}

static intdo_pipe(struct tcb *tcp, int flags_arg){	if (exiting(tcp)) {		if (syserror(tcp)) {			tprintf("%#lx", tcp->u_arg[0]);		} else {#if !defined(SPARC) && !defined(SPARC64) && !defined(SH) && !defined(IA64)			int fds[2];			if (umoven(tcp, tcp->u_arg[0], sizeof fds, (char *) fds) < 0)				tprints("[...]");			else				tprintf("[%u, %u]", fds[0], fds[1]);#elif defined(SPARC) || defined(SPARC64) || defined(SH) || defined(IA64)			tprintf("[%lu, %lu]", tcp->u_rval, getrval2(tcp));#else			tprintf("%#lx", tcp->u_arg[0]);#endif		}		if (flags_arg >= 0) {			tprints(", ");			printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");		}	}	return 0;}

static intdo_accept(struct tcb *tcp, int flags_arg){	if (entering(tcp)) {		printfd(tcp, tcp->u_arg[0]);		tprints(", ");		return 0;	}	if (!tcp->u_arg[2])		tprintf("%#lx, NULL", tcp->u_arg[1]);	else {		int len;		if (tcp->u_arg[1] == 0 || syserror(tcp)		    || umove(tcp, tcp->u_arg[2], &len) < 0) {			tprintf("%#lx", tcp->u_arg[1]);		} else {			printsock(tcp, tcp->u_arg[1], len);		}		tprints(", ");		printnum_int(tcp, tcp->u_arg[2], "%u");	}	if (flags_arg >= 0) {		tprints(", ");		printflags(sock_type_flags, tcp->u_arg[flags_arg],			   "SOCK_???");	}	return 0;}

intsys_sysinfo(struct tcb *tcp){	struct sysinfo si;	if (exiting(tcp)) {		if (syserror(tcp) || !verbose(tcp))			tprintf("%#lx", tcp->u_arg[0]);		else if (umove(tcp, tcp->u_arg[0], &si) < 0)			tprints("{...}");		else {			tprintf("{uptime=%lu, loads=[%lu, %lu, %lu] ",				(long) si.uptime, (long) si.loads[0],				(long) si.loads[1], (long) si.loads[2]);			tprintf("totalram=%lu, freeram=%lu, ",				(long) si.totalram, (long) si.freeram);			tprintf("sharedram=%lu, bufferram=%lu} ",				(long) si.sharedram, (long) si.bufferram);			tprintf("totalswap=%lu, freeswap=%lu, procs=%u}",				(long) si.totalswap, (long) si.freeswap,				(unsigned)si.procs);		}	}	return 0;}

intsys_mincore(struct tcb *tcp){	if (entering(tcp)) {		tprintf("%#lx, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);	} else {		unsigned long i, len;		char *vec = NULL;		len = tcp->u_arg[1];		if (syserror(tcp) || tcp->u_arg[2] == 0 ||			(vec = malloc(len)) == NULL ||			umoven(tcp, tcp->u_arg[2], len, vec) < 0)			tprintf("%#lx", tcp->u_arg[2]);		else {			tprints("[");			for (i = 0; i < len; i++) {				if (abbrev(tcp) && i >= max_strlen) {					tprints("...");					break;				}				tprints((vec[i] & 1) ? "1" : "0");			}			tprints("]");		}		free(vec);	}	return 0;}

static intdo_pipe(struct tcb *tcp, int flags_arg){    if (exiting(tcp)) {        if (syserror(tcp)) {            tprintf("%#lx", tcp->u_arg[0]);        } else {#ifdef HAVE_GETRVAL2            if (flags_arg < 0) {                tprintf("[%lu, %lu]", tcp->u_rval, getrval2(tcp));            } else#endif            {                int fds[2];                if (umove(tcp, tcp->u_arg[0], &fds) < 0)                    tprintf("%#lx", tcp->u_arg[0]);                else                    tprintf("[%u, %u]", fds[0], fds[1]);            }        }        if (flags_arg >= 0) {            tprints(", ");            printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");        }    }    return 0;}

int sys_shmat(struct tcb *tcp){#ifdef LINUX	unsigned long raddr;#endif /* LINUX */	if (exiting(tcp)) {		tprintf("%lu", tcp->u_arg[0]);		if (indirect_ipccall(tcp)) {			tprintf(", %#lx", tcp->u_arg[3]);			tprintf(", ");			printflags(shm_flags, tcp->u_arg[1], "SHM_???");		} else {			tprintf(", %#lx", tcp->u_arg[1]);			tprintf(", ");			printflags(shm_flags, tcp->u_arg[2], "SHM_???");		}		if (syserror(tcp))			return 0;/* HPPA does not use an IPC multiplexer on Linux.  */#if defined(LINUX) && !defined(HPPA)		if (umove(tcp, tcp->u_arg[2], &raddr) < 0)			return RVAL_NONE;		tcp->u_rval = raddr;#endif /* LINUX */		return RVAL_HEX;	}	return 0;}

static intdo_sockname(struct tcb *tcp, int flags_arg){	if (entering(tcp)) {		printfd(tcp, tcp->u_arg[0]);		tprints(", ");		return 0;	}	int len;	if (!tcp->u_arg[2] || !verbose(tcp) || syserror(tcp) ||	    umove(tcp, tcp->u_arg[2], &len) < 0) {		printaddr(tcp->u_arg[1]);		tprints(", ");		printaddr(tcp->u_arg[2]);	} else {		printsock(tcp, tcp->u_arg[1], len);		tprintf(", [%d]", len);	}	if (flags_arg >= 0) {		tprints(", ");		printflags(sock_type_flags, tcp->u_arg[flags_arg],			   "SOCK_???");	}	return 0;}

/** * Generates an RSA private key with the given exponent and number of bits * and writes it to the given file (if specified). */RSA_key_t gen_RSA_key(int bits, int exponent, const char *filename){    RSA_key_t rsa;    FILE *f;    if ((rsa = RSA_generate_key(bits ? bits : DEF_RSA_LEN,                                exponent, NULL, NULL)) == NULL) {        log_ssl_err("couldn't generate rsa key");        return NULL;    }    if (strcmp(filename, "")) {        if ((f = fopen(filename, "rb")) != NULL) {            log(0, 0, "Private key file already exists, won't overwrite");            fclose(f);            return NULL;        }        if ((f = fopen(filename, "wb")) == NULL) {            syserror(0, 0, "failed to open key file");            return NULL;        }        if (!PEM_write_RSAPrivateKey(f, rsa, NULL, NULL, 0, NULL, NULL)) {            log_ssl_err("couldn't write rsa private key");            fclose(f);            return NULL;        }        fclose(f);    }    return rsa;}

static voidprintstatfs64(struct tcb *tcp, long addr){	struct statfs64 statbuf;	if (syserror(tcp) || !verbose(tcp)) {		tprintf("%#lx", addr);		return;	}	if (umove(tcp, addr, &statbuf) < 0) {		tprints("{...}");		return;	}	tprintf("{f_type=%s, f_bsize=%llu, f_blocks=%llu, f_bfree=%llu, ",		sprintfstype(statbuf.f_type),		(unsigned long long)statbuf.f_bsize,		(unsigned long long)statbuf.f_blocks,		(unsigned long long)statbuf.f_bfree);	tprintf("f_bavail=%llu, f_files=%llu, f_ffree=%llu, f_fsid={%d, %d}",		(unsigned long long)statbuf.f_bavail,		(unsigned long long)statbuf.f_files,		(unsigned long long)statbuf.f_ffree,		statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1]);	tprintf(", f_namelen=%lu", (unsigned long)statbuf.f_namelen);#ifdef _STATFS_F_FRSIZE	tprintf(", f_frsize=%llu", (unsigned long long)statbuf.f_frsize);#endif#ifdef _STATFS_F_FLAGS	tprintf(", f_flags=%llu", (unsigned long long)statbuf.f_flags);#endif	tprints("}");}

intsys_read(struct tcb *tcp){  struct socket_info sockinfo;  if (entering(tcp)) {    json_object_object_add(tcp->json, "fd", json_object_new_int((int)tcp->u_arg[0]));    printfd(tcp, tcp->u_arg[0]);    tprintf(", ");    if (output_json) {      if (get_socket_info(tcp->pid, (int) tcp->u_arg[0], &sockinfo) == 0) {        append_to_json(tcp->json, &sockinfo);      } else {        json_object_object_add(tcp->json, "pid", json_object_new_int(tcp->pid));      }    }  } else {    /* exiting... */    if (syserror(tcp)) {      	tprintf("%#lx", tcp->u_arg[1]);    } else {      /* no error */      if (output_json) {        json_object_object_add(tcp->json, "content",            json_object_new_string(readstr(tcp, tcp->u_arg[1], tcp->u_arg[2])));        json_object_object_add(tcp->json, "length", json_object_new_int(tcp->u_arg[2]));      } else {        printstr(tcp, tcp->u_arg[1], tcp->u_rval);      }    }    tprintf(", %lu", tcp->u_arg[2]);  }  return 0;}

/* Read the pid of nacl_helper and get shm from findnacl daemon. * The socket fd is passed in and fd of nacl_helper is returned..*/int recv_pid_fd(int conn){    int fd = -1;    struct msghdr msg = { 0 };    struct iovec iov;    struct cmsghdr *cmsg;    long pid;    char buf[CMSG_SPACE(sizeof(int))];    memset(buf, 0, sizeof(buf));    iov.iov_base = &pid;    iov.iov_len = sizeof(pid);    msg.msg_iov = &iov;    msg.msg_iovlen = 1;    msg.msg_control = buf;    msg.msg_controllen = CMSG_SPACE(sizeof(int));    if (recvmsg(conn, &msg, 0) < 0) {        syserror("Cannot get response from findnacl daemon.");        return -1;    }    cmsg = CMSG_FIRSTHDR(&msg);    if (cmsg) {        if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {            fd = *((int *)CMSG_DATA(cmsg));        } else {            error("No fd is passed from findnacl daemon.");        }    } else {        error("No fd is passed from findnacl daemon.");    }    return fd;}

/** * Returns the next key container for the current user */const char *get_next_container(){    static int flag = CRYPT_FIRST;    static char *item = NULL;    static int mlen = 0;    int rval, len;    if (flag == CRYPT_FIRST) {        rval = CryptGetProvParam(base_prov, PP_ENUMCONTAINERS, NULL,                                 &mlen, CRYPT_FIRST);        if (!rval) {            return NULL;        }        item = malloc(mlen);        if (item == NULL) {            syserror(0, 0, "malloc failed!");            exit(1);        }    }    len = mlen;    rval = CryptGetProvParam(base_prov, PP_ENUMCONTAINERS, item, &len, flag);    if (!rval) {        if (GetLastError() != ERROR_NO_MORE_ITEMS) {            mserror("CryptGetProvParam failed");        }        flag = CRYPT_FIRST;        free(item);        item = NULL;        return NULL;    }    flag = CRYPT_NEXT;    return item;}

/* * A write error has occurred;  if the file being written was * the edited file then we consider it to have changed since it is * now likely scrambled. */static voidwrerror(void){	if (eq(file, savedfile) && edited)		change();	syserror();}