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

void sbbs_t::fileinfo(file_t* f){	char	ext[513];	char 	tmp[512];	char	path[MAX_PATH+1];	char	fpath[MAX_PATH+1];	uint	i,j;	for(i=0;i<usrlibs;i++)		if(usrlib[i]==cfg.dir[f->dir]->lib)			break;	for(j=0;j<usrdirs[i];j++)		if(usrdir[i][j]==f->dir)			break;	getfilepath(&cfg,f,path);	bprintf(text[FiLib],i+1,cfg.lib[cfg.dir[f->dir]->lib]->lname);	bprintf(text[FiDir],j+1,cfg.dir[f->dir]->lname);	bprintf(text[FiFilename],getfname(path));	SAFECOPY(fpath,path);	fexistcase(fpath);	if(strcmp(path,fpath) && strcmp(f->desc,getfname(fpath)))	/* Different "actual" filename */		bprintf(text[FiFilename],getfname(fpath));	if(f->size!=-1L)		bprintf(text[FiFileSize],ultoac(f->size,tmp));	bprintf(text[FiCredits]		,(cfg.dir[f->dir]->misc&DIR_FREE || !f->cdt) ? "FREE" : ultoac(f->cdt,tmp));	bprintf(text[FiDescription],f->desc);	bprintf(text[FiUploadedBy],f->misc&FM_ANON ? text[UNKNOWN_USER] : f->uler);	if(f->date)		bprintf(text[FiFileDate],timestr(&f->date));	bprintf(text[FiDateUled],timestr(&f->dateuled));	bprintf(text[FiDateDled],f->datedled ? timestr(&f->datedled) : "Never");	bprintf(text[FiTimesDled],f->timesdled);	if(f->size!=-1L)		bprintf(text[FiTransferTime],sectostr(f->timetodl,tmp));	if(f->altpath) {		if(f->altpath<=cfg.altpaths) {			if(SYSOP)				bprintf(text[FiAlternatePath],cfg.altpath[f->altpath-1]); 		}		else			bprintf(text[InvalidAlternatePathN],f->altpath); 	}	CRLF;	if(f->misc&FM_EXTDESC) {		getextdesc(&cfg,f->dir,f->datoffset,ext);		CRLF;		putmsg(ext,P_NOATCODES);		CRLF; }	if(f->size==-1L)		bprintf(text[FileIsNotOnline],f->name);	if(f->opencount)		bprintf(text[FileIsOpen],f->opencount,f->opencount>1 ? "s" : nulstr);}

void sbbs_t::show_msghdr(smbmsg_t* msg){	char	str[MAX_PATH+1];	char	*sender=NULL;	int 	i;	attr(LIGHTGRAY);	if(useron.misc&CLRSCRN)		outchar(FF);	else		CRLF;	sprintf(str,"%smenu/msghdr.*", cfg.text_dir);	if(fexist(str)) {		menu("msghdr");		return; 	}	bprintf(text[MsgSubj],msg->subj);	if(msg->hdr.attr)		show_msgattr(msg->hdr.attr);	bprintf(text[MsgTo],msg->to);	if(msg->to_ext)		bprintf(text[MsgToExt],msg->to_ext);	if(msg->to_net.addr)		bprintf(text[MsgToNet],smb_netaddrstr(&msg->to_net,str));	if(!(msg->hdr.attr&MSG_ANONYMOUS) || SYSOP) {		bprintf(text[MsgFrom],msg->from);		if(msg->from_ext)			bprintf(text[MsgFromExt],msg->from_ext);		if(msg->from_net.addr && !strchr(msg->from,'@'))			bprintf(text[MsgFromNet],smb_netaddrstr(&msg->from_net,str)); 	}	bprintf(text[MsgDate]		,timestr(msg->hdr.when_written.time)		,smb_zonestr(msg->hdr.when_written.zone,NULL));	CRLF;	for(i=0;i<msg->total_hfields;i++) {		if(msg->hfield[i].type==SENDER)			sender=(char *)msg->hfield_dat[i];		if(msg->hfield[i].type==FORWARDED && sender)			bprintf(text[ForwardedFrom],sender				,timestr(*(time32_t *)msg->hfield_dat[i])); 	}	CRLF;}

void print_svrstat(const struct svrstat_st* ss, int indent){	time_t boottime = from_nettime(ss->nt_boottime);	char s_boottime[TIME_STRLEN] = { 0 };	timestr(&boottime, s_boottime, sizeof s_boottime);	char s_uuid[UUID_STRLEN] = { 0 };	uuid_unparse(ss->uuid, s_uuid);	char tabs[indent + 1];	ljbx_str_repeat('/t', indent, tabs, sizeof tabs);	fprintf(stderr,		"%s .boottime = %ld (%s)/n"		"%s .seqno = %u/n"		"%s .uuid = %s/n"		"%s .loadavg = %d/n"		, tabs, boottime, s_boottime		, tabs, ss->seqno		, tabs, s_uuid		, tabs, ss->loadavg	);}

static voidreport_stderr(const int fatal, const char *str){	char e[300];	e[0] = '/0';#define REVERSE_VIDEO_ERRORS#ifdef REVERSE_VIDEO_ERRORS	snprintf(e+strlen(e), sizeof(e)-strlen(e), "/x1b[7m"); /* reverse video */#endif	snprintf(e+strlen(e), sizeof(e)-strlen(e), "[%s] ", timestr());	snprintf(e+strlen(e), sizeof(e)-strlen(e), "%s", str);#ifdef REVERSE_VIDEO_ERRORS	snprintf(e+strlen(e), sizeof(e)-strlen(e), "/x1b[0m"); /* reset */#endif	fflush(stdout);	fflush(stderr);	fprintf(stderr, "%s/n", e);	fflush(stderr);	if (fatal) {		fprintf(stderr, "<terminating after fatal error>/n");		report_creat_quitfile();#ifdef FATAL_ASSERT		fflush(stderr);		assert(0);#endif		exit(1);	}}

voidreport_start(int argc, char *argv[]){	char cline[1024], hostname[64];	int i;	if (gettimeofday(&start_tv, NULL) < 0) {		report_perror(FATAL, "gettimeofday");		return;	}	if (gethostname(hostname, sizeof(hostname)) < 0) {		report_perror(FATAL, "gethostname");		return;	}	cline[0] = '/0';	for (i=0 ; i<argc ; i++) {		strncat(cline, argv[i], sizeof(cline) - strlen(cline));		if (i < argc - 1) {			strncat(cline, " ", sizeof(cline) - strlen(cline));		}	}	fprintf(stdout, "[%s] START host /"%s/" command line /"%s/"/n",		timestr(), hostname, cline);	fflush(stdout);}

bool GtkGraph::on_button_press_event(GdkEventButton *event){	if(event->button == 3) // if right-click	{		std::stringstream option(gt::Settings::settings["GraphIntervals"]);		std::vector<unsigned> intervals;		do		{			unsigned tmp;			option >> tmp;			intervals.push_back(tmp);		}while(!option.eof());		Gtk::Menu   *rcMenu = Gtk::manage(new Gtk::Menu());		std::vector<Gtk::MenuItem*> rcItems;		rcItems.resize(intervals.size());		for(unsigned i = 0;i<intervals.size();++i)		{			rcItems[i] = Gtk::manage(new Gtk::MenuItem(timestr(intervals[i])));			rcItems[i]->signal_activate().connect([this,i,intervals](){m_displaySize = intervals[i];});			rcMenu->add(*(rcItems[i]));		}		rcMenu->show_all();		rcMenu->popup(event->button, event->time);	}

extern "C" BOOL DLLCALL hacklog(scfg_t* cfg, char* prot, char* user, char* text, char* host, SOCKADDR_IN* addr){	char	hdr[1024];	char	tstr[64];	char	fname[MAX_PATH+1];	int		file;	time32_t now=time32(NULL);	sprintf(fname,"%shack.log",cfg->logs_dir);	if((file=sopen(fname,O_CREAT|O_RDWR|O_BINARY|O_APPEND,SH_DENYWR,DEFFILEMODE))==-1)		return(FALSE);	sprintf(hdr,"SUSPECTED %s HACK ATTEMPT for user '%s' on %.24s/r/nUsing port %u at %s [%s]/r/nDetails: "		,prot		,user		,timestr(cfg,now,tstr)		,addr->sin_port		,host		,inet_ntoa(addr->sin_addr)		);	write(file,hdr,strlen(hdr));	write(file,text,strlen(text));	write(file,crlf,2);	write(file,crlf,2);	close(file);	return(TRUE);}

/** * Log a message to monits logfile or syslog.  * @param s A formated (printf-style) string to log */void log_log(const char *s, ...) {    long len;  va_list ap;  char *msg= NULL;  ASSERT(s);    va_start(ap,s);  msg= format(s, ap, &len);  va_end(ap);  if(! Run.dolog) goto nolog;  if(Run.use_syslog) {    LOCK(log_mutex)      syslog(LOG_ERR, "%s", msg);    END_LOCK;      } else if(LOG) {    LOCK(log_mutex)      fprintf(LOG,"[%s] %s", timestr(), msg);    END_LOCK;      }  nolog:  LOCK(log_mutex)    fprintf(stderr, "%s", msg);    fflush(stderr);  END_LOCK;    FREE(msg);  }

void sbbs_t::telluser(smbmsg_t* msg){	char str[256];	uint usernumber,n;	node_t node;	if(msg->from_net.type)		return;	if(msg->from_ext)		usernumber=atoi(msg->from_ext);	else {		usernumber=matchuser(&cfg,msg->from,TRUE /*sysop_alias*/);		if(!usernumber)			return; 	}	for(n=1;n<=cfg.sys_nodes;n++) { /* Tell user */		getnodedat(n,&node,0);		if(node.useron==usernumber		&& (node.status==NODE_INUSE		|| node.status==NODE_QUIET)) {			sprintf(str				,text[UserReadYourMailNodeMsg]				,cfg.node_num,useron.alias);			putnmsg(&cfg,n,str);			break; 		} 	}	if(n>cfg.sys_nodes) {		now=time(NULL);		sprintf(str,text[UserReadYourMail]			,useron.alias,timestr(now));		putsmsg(&cfg,usernumber,str); 	}}

/*******************************************************************	printserial()*****************************************************************/static	void	printserial (const char *fname, unsigned long serial){	if ( fname && *fname )		printf ("%-30s/t", fname);	printf ("%10lu", serial);	/* try to guess the soa serial format */	if ( serial < 1136070000L )	/* plain integer (this is 2006-1-1 00:00 in unixtime format) */		;	else if ( serial > 2006010100L )	/* date format */	{		int	y,	m,	d,	v;		v = serial % 100;		serial /= 100;		d = serial % 100;		serial /= 100;		m = serial % 100;		serial /= 100;		y = serial;				printf ("/t%d-%02d-%02d Version %02d", y, m, d, v);	}	else					/* unixtime */		printf ("/t%s/n", timestr (serial) );	printf ("/n");}

static voidsetwakeup(void){	register Seconds_t	t;	register Seconds_t	now;	int			level;	now = CURSECS;	if (!trap.alarms)		t = 0;	else if (trap.alarms->time <= now)		t = 1;	else		t = trap.alarms->time - now;	alarm(t);	sfsprintf(tmpname, MAXNAME, "%lu", t ? (now + t) : t);	setvar(internal.alarm->name, fmtelapsed(t, 1), 0);	if (error_info.trace <= (level = (state.test & 0x00010000) ? 2 : CMDTRACE))	{		register Alarms_t*	a;		if (a = trap.alarms)		{			error(level, "ALARM  TIME                 RULE");			do			{				error(level, "%6s %s %s", fmtelapsed((a->time >= now) ? (a->time - now) : 0, 1), timestr(tmxsns(a->time, 0)), a->rule->name);			} while (a = a->next);		}		else			error(level, "ALARM -- NONE");	}}

static voidprint_v(int nspec){	struct link	*l;	for (l = vcpus; l != NULL; l = l->l_next) {		struct vcpu *v = l->l_ptr;		if ((nspec != 0) && (!v->v_doit))			continue;		(void) printf(_("Status of virtual processor %d as of: "),		    l->l_id);		(void) printf("%s/n", timestr(time(NULL)));		(void) printf(_("  %s since %s./n"),		    _(v->v_state), timestr(v->v_state_begin));		if (v->v_clock_mhz) {			(void) printf(			    _("  The %s processor operates at %llu MHz,/n"),			    v->v_cpu_type, (unsigned long long)v->v_clock_mhz);		} else {			(void) printf(			    _("  The %s processor operates at " /			    "an unknown frequency,/n"), v->v_cpu_type);		}		switch (*v->v_fpu_type) {		case '/0':			(void) printf(			    _("/tand has no floating point processor./n"));			break;		case 'a': case 'A':		case 'e': case 'E':		case 'i': case 'I':		case 'o': case 'O':		case 'u': case 'U':		case 'y': case 'Y':			(void) printf(			    _("/tand has an %s floating point processor./n"),			    v->v_fpu_type);			break;		default:			(void) printf(			    _("/tand has a %s floating point processor./n"),			    v->v_fpu_type);			break;		}	}}

str siglog_startup_msg (){  strbuf msg;  str tm = single_char_sub (timestr (), ':', ".");  msg << "sfsauthd restarted: " << tm << "/n";  return msg;}

void sbbs_t::logentry(const char *code, const char *entry){	char str[512];	now=time(NULL);	sprintf(str,"Node %2d  %s/r/n   %s",cfg.node_num,timestr(now),entry);	logline(code,str);}

void BSSGWriteLowSide(NSMsg *ulmsg){	if (gBSSG.mbsTestQ) {		// For testing, deliver messages to this queue instead:		gBSSG.mbsTestQ->write(ulmsg);	} else {		GPRSLOG(1) << "BSSG ===> writelowside " <<ulmsg->str()<<timestr();		gBSSG.mbsTxQ.write(ulmsg);	// normal mode; block is headed for the SGSN.	}}

int main(){	welcome();	printf("2011:%d, 2012:%d/n",isleap(2011),isleap(2012));	printf("soft01:%d/n", getid("soft01"));	time_t now = time(NULL);	printf("time:%s/n",timestr(localtime(&now)));	char buf[100];	printf("1234543:%s/n", itoa(1234543,buf,sizeof(buf)));	return 0;}

strauthclnt::siglogline (const sfsauth2_sign_arg &arg, const str &uname){  str req = xdr2str (arg);  if (!req) return NULL;  req = armor64 (req);  str tm = single_char_sub (timestr (), ':', ".");  strbuf line;  line << "SIGN:" << uname << ":" << client_name << ":" << tm << ":"        << req << "/n";  return line;}

void *miniGgsnReadServiceLoop(void *arg){	Ggsn *ggsn = (Ggsn*)arg;	sethighpri();	while (ggsn->active()) {		struct pollfd fds[1];		fds[0].fd = tun_fd;		fds[0].events = POLLIN;		fds[0].revents = 0;		// being cautious		// We time out occassionally to check if the user wants to shut the sgsn down.                MGINFO("ggsn: polling at %s",timestr().c_str());		if (-1 == poll(fds,1,ggsn->mStopTimeout)) {			SGSNERROR("ggsn: poll failure");			return 0;		}                MGINFO("ggsn: polling %0x at %s",fds[0].revents,timestr().c_str());		if (fds[0].revents & POLLIN) {			miniggsn_handle_read();		}	}	return 0;}

extern "C" int DLLCALL errorlog(scfg_t* cfg, const char* host, const char* text){	FILE*	fp;	char	buf[128];	char	path[MAX_PATH+1];	sprintf(path,"%serror.log",cfg->logs_dir);	if((fp=fnopen(NULL,path,O_WRONLY|O_CREAT|O_APPEND))==NULL)		return -1; 	fprintf(fp,"%s %s/r/n%s/r/n/r/n", timestr(cfg,time32(NULL),buf), host==NULL ? "":host, text);	fclose(fp);	return 0;}

const string MessageLog::format(const Message& msg, const char prefix){    ostringstream oss;    oss << timestr() << " |"        << fLogData.fSessionID        << '|' << fLogData.fTxnID        << '|' << fLogData.fThdID        << "| "        << prefix << ' ' << setw(2) << setfill('0') << fLogData.fSubsysID        << ' ' << msg.msg()        ;    return escape_pct(oss.str());}

voidreport_stop(int print_rusage){	float usertime, systemtime, totaltime;	struct timeval end_tv;	struct rusage rusage;	if (gettimeofday(&end_tv, NULL) < 0) {		report_perror(FATAL, "gettimeofday");		return;	}	if (getrusage(RUSAGE_SELF, &rusage) == -1) {		report_perror(FATAL, "getrusage");		return;	}	fprintf(stdout, "[%s] STOP/n", timestr());	fflush(stdout);	if (!print_rusage) {		return;	}	totaltime = (float)(end_tv.tv_sec - start_tv.tv_sec) + 		(float)(end_tv.tv_usec - start_tv.tv_usec)/1000000.0;	usertime = (float)rusage.ru_utime.tv_sec + 		((float)rusage.ru_utime.tv_usec)/1000000.0;	systemtime = (float)rusage.ru_stime.tv_sec + 		((float)rusage.ru_stime.tv_usec)/1000000.0;	printf(">>> real(s):                     %9.2f/n", totaltime);	printf(">>> user(s):                     %9.2f (%0.2f%%)/n", 	       usertime, 100.0*usertime/totaltime);	printf(">>> sys(s):                      %9.2f (%0.2f%%)/n", 	       systemtime, 100.0*systemtime/totaltime);	printf(">>> /"idle/"(s):                   %9.2f (%0.2f%%)/n", 	       totaltime-(usertime+systemtime),	       100.0*(totaltime-(usertime+systemtime))/totaltime);	printf(">>> maximal resident set size(KB): %7ld/n", rusage.ru_maxrss);	printf(">>> integral resident set size:    %7ld/n", rusage.ru_idrss);	printf(">>> page faults not requiring I/O: %7ld/n", rusage.ru_minflt);	printf(">>> page faults requiring I/O:     %7ld/n", rusage.ru_majflt);	printf(">>> swaps:                         %7ld/n", rusage.ru_nswap);	printf(">>> input operations:              %7ld/n", rusage.ru_inblock);	printf(">>> output operations:             %7ld/n", rusage.ru_oublock);	printf(">>> msgsnd operations:             %7ld/n", rusage.ru_msgsnd);	printf(">>> msgrcv operations:             %7ld/n", rusage.ru_msgrcv);	printf(">>> signals handled:               %7ld/n", rusage.ru_nsignals);	printf(">>> voluntary context switches:    %7ld/n", rusage.ru_nvcsw);	printf(">>> involuntary context switches:  %7ld/n", rusage.ru_nivcsw);}

static voidprint_normal(int nspec){	struct link	*l;	struct vcpu	*v;	for (l = vcpus; l != NULL; l = l->l_next) {		v = l->l_ptr;		if ((nspec == 0) || (v->v_doit)) {			(void) printf(_("%d/t%-8s  since %s/n"),			    l->l_id, _(v->v_state), timestr(v->v_state_begin));		}	}}

unsigned char *miniggsn_rcv_npdu(int *plen, uint32_t *dstaddr){	static unsigned char *recvbuf = NULL;	if (recvbuf == NULL) {		recvbuf = (unsigned char*)malloc(ggConfig.mgMaxPduSize+2);		if (!recvbuf) { /**error = -ENOMEM;*/ return NULL; }	}	// The O_NONBLOCK was set by default!  Is not happening any more.	{		int flags = fcntl(tun_fd,F_GETFL,0);		if (flags & O_NONBLOCK) {			//MGDEBUG(4,"O_NONBLOCK = %d",O_NONBLOCK & flags);			flags &= ~O_NONBLOCK;	// Want Blocking!			int fcntlstat = fcntl(tun_fd,F_SETFL,flags);			MGWARN("ggsn: WARNING: Turning off tun_fd blocking flag, fcntl=%d",fcntlstat);		}	}	// We can just read from the tunnel.	int ret = read(tun_fd,recvbuf,ggConfig.mgMaxPduSize);	if (ret < 0) {		MGERROR("ggsn: error: reading from tunnel: %s", strerror(errno));		//*error = ret;		return NULL;	} else if (ret == 0) {		MGERROR("ggsn: error: zero bytes reading from tunnel: %s", strerror(errno));		//*error = ret;	// huh?		return NULL;	} else {		struct iphdr *iph = (struct iphdr*)recvbuf;		{			char infobuf[200];			MGINFO("ggsn: received %s at %s",packettoa(infobuf,recvbuf,ret), timestr().c_str());			//MGLOGF("ggsn: received proto=%s %d byte npdu from %s for %s at %s",				//ip_proto_name(iph->protocol), ret,				//ip_ntoa(iph->saddr,nbuf),				//ip_ntoa(iph->daddr,NULL), timestr());		}		*dstaddr = iph->daddr;		// TODO: Do we have to allocate a new buffer?		*plen = ret;		// Zero terminate for the convenience of the pinger.		recvbuf[ret] = 0;		return recvbuf;	}}

void xChLogo(char n){    char logo[10]="XCHLOGO_";    int x=x_maxx()-150,y=0;    if(fullscreen || customerscreen)        return;#ifndef TEXTONLY    if(arachne.GUIstyle==STYLE_SMALL1 || arachne.GUIstyle==STYLE_SMALL2)    {        if(n=='0')        {            int y=3;            if(arachne.GUIstyle==STYLE_SMALL2)                y=4;            if(!user_interface.iconsoff)                DrawIconNow( "ALTICON2",x_maxx()-146,y );            return;        }        sprintf(logo,"SMALOGO_");        x=x_maxx()-19;        if(arachne.GUIstyle==STYLE_SMALL1)            y=5;        else            y=6;        if(n>'4' && n<'A')n-=4;    }    logo[7]=n;    DrawIconNow(  logo, x,y);    if(ppplogtime && tcpip)    {        char cas[32];        timestr(cas);        if (strcmp(lasttime,cas) == 0 ) return;        strcpy(lasttime,cas);        draw_time_online();    }#endif//textonly}//end sub

/* * Log to file and/or syslog as directed. We want different * behaviour before syslog has been called and set up; and * different behaviour before we fork for ssh: errors before * that point result in exit. */voiddoerrlog(int level, char *fmt, va_list ap){	FILE	*fl;#ifndef HAVE_VSYSLOG	char	logbuf[1024];#endif	fl = flog;	/* only set per-call */	if (loglevel >= level) {		if (logtype & L_SYSLOG) {#ifdef __ANDROID__			(void)vsnprintf(logbuf, sizeof(logbuf), fmt, ap);			__android_log_print(ANDROID_LOG_DEBUG, "autossh", logbuf, 1);#else#ifndef HAVE_VSYSLOG			(void)vsnprintf(logbuf, sizeof(logbuf), fmt, ap);			syslog(level, logbuf);#else			vsyslog(level, fmt, ap);#endif#endif		} else if (!fl) {			/* 			 * if we're not using syslog, and we			 * don't have a log file, then use			 * stderr.			 */			fl = stderr;		}		if ((logtype & L_FILELOG) && fl) {			fprintf(fl, 			    "%s %s[%d]: ", timestr(),			    __progname, (int)getpid());			vfprintf(fl, fmt, ap);			fprintf(fl, "/n");			fflush(fl);		}	}	return;}

extern "C" BOOL DLLCALL spamlog(scfg_t* cfg, char* prot, char* action								,char* reason, char* host, char* ip_addr								,char* to, char* from){	char	hdr[1024];	char	to_user[256];	char	tstr[64];	char	fname[MAX_PATH+1];	int		file;	time32_t now=time32(NULL);	sprintf(fname,"%sspam.log",cfg->logs_dir);	if((file=sopen(fname,O_CREAT|O_RDWR|O_BINARY|O_APPEND,SH_DENYWR,DEFFILEMODE))==-1)		return(FALSE);	if(to==NULL)		to_user[0]=0;	else		sprintf(to_user,"to: %.128s",to);	if(from==NULL)		from=host;			sprintf(hdr,"SUSPECTED %s SPAM %s on %.24s/r/nHost: %s [%s]/r/nFrom: %.128s %s/r/nReason: "		,prot		,action		,timestr(cfg,now,tstr)		,host		,ip_addr		,from		,to_user		);	write(file,hdr,strlen(hdr));	if(reason!=NULL)		write(file,reason,strlen(reason));	write(file,crlf,2);	write(file,crlf,2);	close(file);	return(TRUE);}

void post_dream (DESCRIPTOR_DATA *d){    char		*p = NULL;    char        *date = NULL;    DREAM_DATA	*dream;    CHAR_DATA	*ch;    p = d->character->delay_who;    ch = d->character->delay_ch;    if ( !p || !*p ) {        send_to_char ("Dream aborted./n/r", d->character);        unload_pc (d->character->delay_ch);        return;    }    CREATE (dream, DREAM_DATA, 1);    dream->dream = d->character->delay_who;    dream->next  = ch->pc->dreams;    d->character->delay_who = NULL;    ch->pc->dreams = dream;    send_to_char ("Dream added./n/r", d->character);    date = timestr(date);    add_message (GET_NAME (ch),                          /* PC board */                 3,                                     /* message # */                 GET_NAME (d->character),                /* Imm name */                 date,                 "Entry via GIVEDREAM command.",                 "",                 dream->dream,                 MF_DREAM);    unload_pc (ch);    mem_free (date);}

static void print_report(const char *op, struct timeval *t, int64_t offset,                         int count, int total, int cnt, int Cflag){    char s1[64], s2[64], ts[64];    timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);    if (!Cflag) {        cvtstr((double)total, s1, sizeof(s1));        cvtstr(tdiv((double)total, *t), s2, sizeof(s2));        printf("%s %d/%d bytes at offset %" PRId64 "/n",               op, total, count, offset);        printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)/n",               s1, cnt, ts, s2, tdiv((double)cnt, *t));    } else {/* bytes,ops,time,bytes/sec,ops/sec */        printf("%d,%d,%s,%.3f,%.3f/n",            total, cnt, ts,            tdiv((double)total, *t),            tdiv((double)cnt, *t));    }}