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

static int do_lock_dirs(struct sdirs *sdirs, struct conf *conf){	int ret=-1;	char *lockbase=NULL;	char *lockfile=NULL;	if(conf->client_lockdir)	{		if(!(sdirs->lockdir=strdup_w(conf->client_lockdir, __func__))		  || !(lockbase=prepend_s(sdirs->lockdir, conf->cname)))			goto end;	}	else	{		if(!(sdirs->lockdir=strdup_w(sdirs->client, __func__))		  || !(lockbase=strdup_w(sdirs->client, __func__)))			goto end;	}	if(!(lockfile=prepend_s(lockbase, "lockfile"))	  || !(sdirs->lock=lock_alloc_and_init(lockfile)))		goto end;	ret=0;end:	free_w(&lockbase);	free_w(&lockfile);	return ret;}

static void run_test(int expected_ret,	void setup_asfds_callback(struct asfd *sfd,		struct asfd *in, struct asfd *out)){	struct async *as;	struct asfd *sfd;	struct asfd *in;	struct asfd *out;	as=setup();	sfd=asfd_mock_setup(&areads, &awrites);	in=asfd_mock_setup(&ireads, &iwrites);	out=asfd_mock_setup(&oreads, &owrites);	fail_unless((sfd->desc=strdup_w("main_socket", __func__))!=NULL);	fail_unless((in->desc=strdup_w("stdin", __func__))!=NULL);	fail_unless((out->desc=strdup_w("stdout", __func__))!=NULL);	as->asfd_add(as, sfd);	as->asfd_add(as, in);	as->asfd_add(as, out);	as->read_write=async_rw_both;	setup_asfds_callback(sfd, in, out);	fail_unless(monitor_client_main_loop(as)==expected_ret);	asfd_free(&in);	asfd_free(&out);	asfd_free(&sfd);	asfd_mock_teardown(&areads, &awrites);	asfd_mock_teardown(&ireads, &iwrites);	asfd_mock_teardown(&oreads, &owrites);	tear_down(&as);}

static struct manio *do_manio_open(const char *manifest, const char *mode,	enum protocol protocol, int phase){	struct manio *manio=NULL;	if(!(manio=manio_alloc())	  || !(manio->manifest=strdup_w(manifest, __func__))	  || !(manio->mode=strdup_w(mode, __func__))	  || !(manio->offset=man_off_t_alloc()))		goto error;	manio->protocol=protocol;	manio->phase=phase;	if(!strcmp(manio->mode, MANIO_MODE_APPEND))	{		if(manio->phase!=2)		{			logp("manio append mode only works for phase 2./n");			logp("%s has phase: %s/n",				manio->manifest, manio->phase);			goto error;		}		if(manio_open_last_fpath(manio))			goto error;	}	else	{		if(manio_open_next_fpath(manio))			goto error;	}	return manio;error:	manio_close(&manio);	return NULL;}

static NTSTATUS mangle_get_prefix(const smb_ucs2_t *ucs2_string, smb_ucs2_t **prefix,		smb_ucs2_t **extension, bool allow_wildcards){	size_t ext_len;	smb_ucs2_t *p;	*extension = 0;	*prefix = strdup_w(ucs2_string);	if (!*prefix) {		return NT_STATUS_NO_MEMORY;	}	if ((p = strrchr_w(*prefix, UCS2_CHAR('.')))) {		ext_len = strlen_w(p+1);		if ((ext_len > 0) && (ext_len < 4) && (p != *prefix) &&		    (NT_STATUS_IS_OK(has_valid_83_chars(p+1,allow_wildcards)))) /* check extension */ {			*p = 0;			*extension = strdup_w(p+1);			if (!*extension) {				SAFE_FREE(*prefix);				return NT_STATUS_NO_MEMORY;			}		}	}	return NT_STATUS_OK;}

int check_browsedir(const char *browsedir,                    struct sbuf *mb, size_t bdlen, char **last_bd_match){    char *cp=mb->path.buf;    char *copy=NULL;    if(bdlen>0)    {        if(strncmp(browsedir, cp, bdlen))            return 0;        cp+=bdlen;        if(browsedir[bdlen-1]!='/')        {            if(*cp!='/0')            {                if(*cp!='/')                    return 0;                cp++;            }        }    }    if(*cp=='/0')        cp=(char *)".";    if(!(copy=strdup_w(cp, __func__)))        goto error;    if((cp=strchr(copy, '/')))    {        if(bdlen==0) cp++;        *cp='/0';        maybe_fake_directory(mb);    }    else if(!strcmp(mb->path.buf, "/")            && !strcmp(browsedir, "/"))        maybe_fake_directory(mb);    else if(mb->path.cmd==CMD_DIRECTORY)        maybe_fake_directory(mb);    // Strip off possible trailing slash.    if((cp=strrchr(copy, '/')) && cp>copy)        *cp='/0';    if(*last_bd_match            && !strcmp(*last_bd_match, copy))    {        // Got a duplicate match.        free_w(&copy);        return 0;    }    free_w(&mb->path.buf);    mb->path.buf=copy;    free_w(last_bd_match);    if(!(*last_bd_match=strdup_w(copy, __func__)))        goto error;    return 1;error:    free_w(&copy);    log_out_of_memory(__func__);    return -1;}

static int run_list(struct asfd *asfd,	struct sdirs *sdirs, struct conf **cconfs){	int ret=-1;	char *cp=NULL;	char *backupno=NULL;	char *browsedir=NULL;	char *listregex=NULL;	struct iobuf *rbuf=asfd->rbuf;	if(!client_can_generic(cconfs, OPT_CLIENT_CAN_LIST))	{		logp("Not allowing list of %s/n",			get_string(cconfs[OPT_CNAME]));		asfd->write_str(asfd, CMD_GEN, "Client list is not allowed");		goto end;	}	if(!strncmp_w(rbuf->buf, "list "))	{		if((cp=strchr(rbuf->buf, ':')))		{			*cp='/0';			if(!(listregex=strdup_w(cp+1, __func__)))				goto end;		}		if(!(backupno=strdup_w(rbuf->buf+strlen("list "), __func__)))			goto end;			}	else if(!strncmp_w(rbuf->buf, "listb "))	{		if((cp=strchr(rbuf->buf, ':')))		{			*cp='/0';			if(!(browsedir=strdup_w(cp+1, __func__)))				goto end;		}		strip_trailing_slashes(&browsedir);		if(!(backupno=strdup_w(rbuf->buf+strlen("listb "), __func__)))			goto end;	}	if(asfd->write_str(asfd, CMD_GEN, "ok")) goto end;	iobuf_free_content(asfd->rbuf);	if(list_server_init(asfd, sdirs, get_cntr(cconfs),		get_protocol(cconfs), backupno, listregex, browsedir))			goto end;	ret=do_list_server();end:	free_w(&backupno);	free_w(&browsedir);	free_w(&listregex);	list_server_free();	return ret;}

int check_browsedir(const char *browsedir, char **path,	size_t bdlen, char **last_bd_match){	char *cp=NULL;	char *copy=NULL;	if(strncmp(browsedir, *path, bdlen))		return 0;	if((*path)[bdlen+1]=='/0' || (bdlen>1 && (*path)[bdlen]!='/'))		return 0;	/* Lots of messing around related to whether browsedir was '', '/', or   	   something else. */	if(*browsedir)	{		if(!strcmp(browsedir, "/"))		{			if(!(copy=strdup_w((*path)+bdlen, __func__)))				goto error;			if((cp=strchr(copy+1, '/'))) *cp='/0';		}		else		{			if(!(copy=strdup_w((*path)+bdlen+1, __func__)))				goto error;			if((cp=strchr(copy, '/'))) *cp='/0';		}	}	else	{		if(!(copy=strdup_w((*path)+bdlen, __func__)))			goto error;		if(*copy=='/') *(copy+1)='/0';		// Messing around for Windows.		else if(strlen(copy)>2 && copy[1]==':' && copy[2]=='/')			copy[2]='/0';	}	if(last_bd_match && *last_bd_match)	{		if(!strcmp(*last_bd_match, copy))		{			// Got a duplicate match.			free(copy);			return 0;		}		free(*last_bd_match);	}	free(*path);	*path=copy;	if(!(*last_bd_match=strdup_w(copy, __func__)))		goto error;	return 1;error:	if(copy) free(copy);	log_out_of_memory(__func__);	return -1;}

static int init_write_hooks(struct manio *manio,	const char *hook_dir, const char *rmanifest){	if(!(manio->hook_dir=strdup_w(hook_dir, __func__))	  || !(manio->rmanifest=strdup_w(rmanifest, __func__))	  || !(manio->hook_sort=(uint64_t *)calloc_w(MANIFEST_SIG_MAX,		sizeof(uint64_t), __func__)))			return -1;	return 0;}

static void do_snapshot_test(	const char *orig_client,	int expected_ret,	void setup_callback(		struct asfd *csin,		struct asfd *csout,		struct asfd *so_asfd	)){	struct asfd *csin;	struct asfd *csout;	struct asfd *so_asfd;	struct async *as;	struct sel *sel;	as=setup_async();	csin=asfd_mock_setup(&reads_csin, &writes_csin);	csout=asfd_mock_setup(&reads_csout, &writes_csout);	so_asfd=asfd_mock_setup(&reads_so, &writes_so);        fail_unless((csin->desc=strdup_w("csin", __func__))!=NULL);        fail_unless((csout->desc=strdup_w("csout", __func__))!=NULL);        fail_unless((so_asfd->desc=strdup_w("so_asfd", __func__))!=NULL);	as->asfd_add(as, csin);	as->asfd_add(as, csout);	as->asfd_add(as, so_asfd);	as->read_write=async_rw_simple;	as->write=async_write_simple;	setup_callback(csin, csout, so_asfd);	fail_unless((sel=sel_alloc())!=NULL);	fail_unless(!status_client_ncurses_init(ACTION_STATUS_SNAPSHOT));	fail_unless(status_client_ncurses_main_loop(		as,		so_asfd,		sel,		orig_client	)==expected_ret);	sel_free(&sel);	asfd_free(&csin);	asfd_free(&csout);	asfd_free(&so_asfd);	asfd_mock_teardown(&reads_csin, &writes_csin);	asfd_mock_teardown(&reads_csout, &writes_csout);	asfd_mock_teardown(&reads_so, &writes_so);	async_free(&as);	alloc_check();}

static void run_test(int expected_ret,	int manio_entries,	int async_read_write_callback(struct async *as),	void setup_asfds_callback(struct asfd *asfd, struct asfd *chfd,		struct slist *slist)){	struct asfd *asfd;	struct asfd *chfd;	struct async *as;	struct sdirs *sdirs;	struct conf **confs;	struct slist *slist=NULL;	prng_init(0);	base64_init();	hexmap_init();	setup(&as, &sdirs, &confs);	asfd=asfd_mock_setup(&areads, &awrites);	chfd=asfd_mock_setup(&creads, &cwrites);	fail_unless((asfd->desc=strdup_w("a", __func__))!=NULL);	fail_unless((chfd->desc=strdup_w("c", __func__))!=NULL);	as->asfd_add(as, asfd);	as->asfd_add(as, chfd);	as->read_write=async_read_write_callback;	if(manio_entries)		slist=build_manifest(sdirs->phase1data,			PROTO_2, manio_entries, 1 /*phase*/);	setup_asfds_callback(asfd, chfd, slist);	fail_unless(do_backup_phase2_server_protocol2(		as,		chfd,		sdirs,		0, // resume		confs	)==expected_ret);	if(!expected_ret)	{		// FIX THIS: Should check for the presence and correctness of		// changed and unchanged manios.	}	asfd_free(&asfd);	asfd_free(&chfd);	asfd_mock_teardown(&areads, &awrites);	asfd_mock_teardown(&creads, &cwrites);	slist_free(&slist);	tear_down(&as, &sdirs, &confs);}

int manio_init_write_hooks(struct manio *manio,	const char *base_dir, const char *dir){	int i=0;	if(!(manio->base_dir=strdup_w(base_dir, __func__))	  || !(manio->hook_dir=strdup_w(dir, __func__))	  || !(manio->hook_sort=		(char **)calloc_w(MANIFEST_SIG_MAX, sizeof(char*), __func__)))			return -1;	for(i=0; i<MANIFEST_SIG_MAX; i++)		if(!(manio->hook_sort[i]=			(char *)calloc_w(1, WEAK_STR_LEN, __func__)))				return -1;	return 0;}

static#endifint conf_load_lines_from_buf(const char *buf, struct conf **c){	int ret=0;	int line=0;	char *tok=NULL;	char *copy=NULL;	if(!buf) return 0;	if(!(copy=strdup_w(buf, __func__))) return -1;	if(!(tok=strtok(copy, "/n")))	{		logp("unable to parse conf buffer/n");		free_w(&copy);		return -1;	}	do	{		line++;		if(conf_parse_line(c, "", tok, line))		{			ret=-1;			break;		}	} while((tok=strtok(NULL, "/n")));	free_w(&copy);	return ret;}

// When a backup is ongoing, use this to add newly complete candidates.int candidate_add_fresh(const char *path, const char *directory,	struct scores *scores){	const char *cp=NULL;	struct candidate *candidate=NULL;	if(!(candidate=candidates_add_new()))		goto error;	cp=path+strlen(directory);	while(cp && *cp=='/') cp++;	if(!(candidate->path=strdup_w(cp, __func__)))		goto error;	switch(candidate_load(candidate, path, scores))	{		case CAND_RET_PERM:			goto error;		case CAND_RET_TEMP:			// Had an error - try to carry on. Errors can happen			// when loading a fresh candidate because the backup			// process can move to the next phase and rename the			// candidates.			logp("Removing candidate./n");			candidates_len--;			sparse_delete_fresh_candidate(candidate);			candidate_free(&candidate);			// Fall through.		case CAND_RET_OK:			return 0;	}error:	candidate_free(&candidate);	return -1;}

static int conf_parse_line(struct conf **confs, const char *conf_path,	char buf[], int line){	int ret=-1;	char *f=NULL; // field	char *v=NULL; // value	char *extrafile=NULL;	if(!strncmp(buf, ". ", 2))	{		// The conf file specifies another file to include.		char *np=NULL;		if(!(extrafile=strdup_w(buf+2, __func__))) goto end;		if((np=strrchr(extrafile, '/n'))) *np='/0';		if(!*extrafile) goto end;		ret=deal_with_dot_inclusion(conf_path, &extrafile, confs);		goto end;	}	if(conf_get_pair(buf, &f, &v)) goto end;	if(f && v	  && load_conf_field_and_value(confs, f, v, conf_path, line))		goto end;	ret=0;end:	free_w(&extrafile);	return ret;}

static char *set_new_datapth(struct asfd *asfd,	struct sdirs *sdirs, struct conf **cconfs,	struct sbuf *sb, struct dpth *dpth, int *istreedata){	char *tmp=NULL;	char *rpath=NULL;	if(get_int(cconfs[OPT_DIRECTORY_TREE]))		*istreedata=treedata(sb, cconfs);	if(*istreedata)	{		// We want to place this file in a directory structure like		// the directory structure on the original client.		if(!(tmp=prepend_s(TREE_DIR, sb->path.buf)))		{			log_and_send_oom(asfd, __func__);			return NULL;		}	}	else	{		if(!(tmp=strdup_w(dpth_protocol1_mk(dpth,			get_int(cconfs[OPT_COMPRESSION]),			sb->path.cmd), __func__))) return NULL;	}	iobuf_from_str(&sb->protocol1->datapth, CMD_DATAPTH, tmp);	if(build_path(sdirs->datadirtmp,		sb->protocol1->datapth.buf, &rpath, sdirs->datadirtmp))	{		log_and_send(asfd, "build path failed");		return NULL;	}	return rpath;}

// Return 1 for ok, -1 for error, 0 for too many components stripped.static int strip_path_components(struct asfd *asfd,	struct sbuf *sb, int strip, struct cntr *cntr, enum protocol protocol){	int s=0;	char *tmp=NULL;	char *cp=sb->path.buf;	char *dp=NULL;	for(s=0; cp && *cp && s<strip; s++)	{		if(!(dp=strchr(cp, '/')))		{			char msg[256]="";			snprintf(msg, sizeof(msg),			  "Stripped too many components: %s", sb->path.buf);			if(restore_interrupt(asfd, sb, msg, cntr, protocol))				return -1;			return 0;		}		cp=dp+1;	}	if(!cp)	{		char msg[256]="";		snprintf(msg, sizeof(msg),			"Stripped too many components: %s", sb->path.buf);		if(restore_interrupt(asfd, sb, msg, cntr, protocol))			return -1;		return 0;	}	if(!(tmp=strdup_w(cp, __func__)))		return -1;	free_w(&sb->path.buf);	sb->path.buf=tmp;	return 1;}

extern int sdirs_init(struct sdirs *sdirs, struct conf *conf){	if(!conf->directory)	{		logp("conf->directory unset in %s/n", __func__);		goto error;	}	if(!(sdirs->base=strdup_w(conf->directory, __func__)))		goto error;	if(conf->protocol==PROTO_BURP1)	{		if(do_burp1_dirs(sdirs, conf)) goto error;	}	else	{		if(do_burp2_dirs(sdirs, conf)) goto error;	}	if(do_lock_dirs(sdirs, conf)) goto error;	return 0;error:	return -1;}

END_TESTSTART_TEST(test_check_browsedir_alloc_error){	char *path;	size_t bdlen;	struct sbuf *mb;	const char *browsedir;	char *last_bd_match=NULL;	fail_unless((mb=sbuf_alloc(PROTO_1))!=NULL);	browsedir="";	bdlen=0;	fail_unless((path=strdup_w("aaa", __func__))!=NULL);	iobuf_from_str(&mb->path, CMD_FILE, path);	alloc_errors=1;	fail_unless(check_browsedir(		browsedir,		mb,		bdlen,		&last_bd_match)			==-1);	sbuf_free(&mb);	free_w(&last_bd_match);	alloc_check();}

END_TESTstatic void run_check_browsedir(const char *browsedir,	struct sbuf *mb,	enum cmd cmd,	const char *path,	char **last_bd_match,	const char *expected_last_bd_match,	int expected_ret,	int expected_isdir){	char *mbpath;	size_t bdlen=0;	if(browsedir) bdlen=strlen(browsedir);	fail_unless((mbpath=strdup_w(path, __func__))!=NULL);	iobuf_from_str(&mb->path, cmd, mbpath);	fail_unless(check_browsedir(		browsedir,		mb,		bdlen,		last_bd_match)			==expected_ret);	if(expected_last_bd_match)	{		fail_unless(*last_bd_match!=NULL);		ck_assert_str_eq(expected_last_bd_match, *last_bd_match);	}	else		fail_unless(*last_bd_match==NULL);	fail_unless(expected_isdir==S_ISDIR(mb->statp.st_mode));	sbuf_free_content(mb);}

// Return 0 for lock got, 1 for lock not got, -1 for error.void lock_get(struct lock *lock){#if defined(HAVE_WIN32) || !defined(HAVE_LOCKF)	// Would somebody please tell me how to get a lock on Windows?!	lock->status=GET_LOCK_GOT;	return;#else	char *cp=NULL;        char *copy=NULL;        // Try to make sure the lock directory exists.        if(!(copy=strdup_w(lock->path, __func__)))	{		lock->status=GET_LOCK_ERROR;		return;	}	if((cp=strrchr(copy, '/')))	{		*cp='/0';		if(*copy) mkdir(copy, 0777);	}	free_w(&copy);	lock_get_quick(lock);	// Try to make sure the pid gets onto the disk.	if(lock->status==GET_LOCK_GOT) fsync(lock->fd);	return;#endif}

int lock_init(struct lock *lock, const char *path){	free_w(&lock->path);	if(!(lock->path=strdup_w(path, __func__)))		return -1;	return 0;}

static int load_rblk(struct rblk *rblks, int ind, const char *datpath){    int r;    FILE *dfp;    free_w(&rblks[ind].datpath);    if(!(rblks[ind].datpath=strdup_w(datpath, __func__)))        return -1;    printf("swap %d to: %s/n", ind, datpath);    if(!(dfp=open_file(datpath, "rb"))) return -1;    for(r=0; r<DATA_FILE_SIG_MAX; r++)    {        switch(read_next_data(dfp, rblks, ind, r))        {        case 0:            continue;        case 1:            break;        case -1:        default:            return -1;        }    }    rblks[ind].readbuflen=r;    fclose(dfp);    return 0;}

static int parse_restore_str(const char *str, enum action *act,	char **backupnostr, char **restoreregex){	int ret=-1;	char *cp=NULL;	char *copy=NULL;	if(!str)	{		logp("NULL passed to %s/n", __func__);		goto end;	}	if(!(copy=strdup_w(str, __func__)))		goto end;	if(!strncmp_w(copy, "restore "))		*act=ACTION_RESTORE;	else if(!strncmp_w(copy, "verify "))		*act=ACTION_VERIFY;	else	{		logp("Could not parse %s in %s/n", copy, __func__);		goto end;	}	if(!(cp=strchr(copy, ' ')))	{		logp("Could not parse %s in %s/n", copy, __func__);		goto end;	}	cp++;	if(!(*backupnostr=strdup_w(cp, __func__)))		goto end;	if((cp=strchr(*backupnostr, ':')))	{		*cp='/0';		cp++;		if(!(*restoreregex=strdup_w(cp, __func__)))			goto end;	}	ret=0;end:	free_w(&copy);	return ret;}

static char *get_next_fpath(struct manio *manio, man_off_t *offset){	static char tmp[32];	if(is_single_file(manio))		return strdup_w(manio->manifest, __func__);	snprintf(tmp, sizeof(tmp), "%08"PRIX64, offset->fcount++);	return prepend_s(manio->manifest, tmp);}

static int init_write_dindex(struct manio *manio, const char *dir){	if(!(manio->dindex_dir=strdup_w(dir, __func__))	  || !(manio->dindex_sort=(uint64_t *)calloc_w(MANIFEST_SIG_MAX,		sizeof(uint64_t), __func__)))			return -1;	return 0;}

static int check_timebands(const char *day_now, const char *hour_now,	struct strlist *timebands){	char *lower_tb=NULL;	int in_timeband=0;	struct strlist *t;	char *lower_day_now=NULL;	char *lower_hour_now=NULL;	if(!(lower_day_now=strdup_w(day_now, __func__))	  || !(lower_hour_now=strdup_w(hour_now, __func__)))	{		in_timeband=-1;		goto end;	}	strtolower(lower_day_now);	strtolower(lower_hour_now);	for(t=timebands; t; t=t->next)	{		free_w(&lower_tb);		if(!(lower_tb=strdup_w(t->path, __func__)))		{			in_timeband=-1;			goto end;		}		strtolower(lower_tb);		if(!strcmp(lower_tb, "always")		  || (strstr(lower_tb, lower_day_now)		    && strstr(lower_tb, lower_hour_now)))		{			logp("In timeband: %s/n", t->path);			in_timeband=1;		}		else			logp("Out of timeband: %s/n", t->path);	}end:	free_w(&lower_day_now);	free_w(&lower_hour_now);	free_w(&lower_tb);	return in_timeband;}

int cstat_init(struct cstat *cstat,	const char *name, const char *clientconfdir){	if((clientconfdir && !(cstat->conffile=prepend_s(clientconfdir, name)))	  || !(cstat->name=strdup_w(name, __func__)))		return -1;	return 0;}

static char *get_restore_style(struct asfd *asfd, struct conf **confs){	if(get_protocol(confs)==PROTO_1)		return strdup_w(RESTORE_STREAM, __func__);	if(asfd->simple_loop(asfd, confs, NULL, __func__,		restore_style_func)) return NULL;	return restore_style;}

// Return 1 if there is still stuff needing to be sent.static int do_stuff_to_send(struct asfd *asfd,	struct sbuf *p1b, char **last_requested){	static struct iobuf wbuf;	if(p1b->flags & SBUFL_SEND_DATAPTH)	{		iobuf_copy(&wbuf, &p1b->burp1->datapth);		if(asfd->append_all_to_write_buffer(asfd, &wbuf))			return 1;		p1b->flags &= ~SBUFL_SEND_DATAPTH;	}	if(p1b->flags & SBUFL_SEND_STAT)	{		iobuf_copy(&wbuf, &p1b->attr);		if(asfd->append_all_to_write_buffer(asfd, &wbuf))			return 1;		p1b->flags &= ~SBUFL_SEND_STAT;	}	if(p1b->flags & SBUFL_SEND_PATH)	{		iobuf_copy(&wbuf, &p1b->path);		if(asfd->append_all_to_write_buffer(asfd, &wbuf))			return 1;		p1b->flags &= ~SBUFL_SEND_PATH;		if(*last_requested) free(*last_requested);		if(!(*last_requested=strdup_w(p1b->path.buf, __func__)))			return -1;	}	if(p1b->burp1->sigjob && !(p1b->flags & SBUFL_SEND_ENDOFSIG))	{		rs_result sigresult;		sigresult=rs_async(p1b->burp1->sigjob, &(p1b->burp1->rsbuf),			p1b->burp1->infb, p1b->burp1->outfb);		if(sigresult==RS_DONE)		{			p1b->flags |= SBUFL_SEND_ENDOFSIG;		}		else if(sigresult==RS_BLOCKED || sigresult==RS_RUNNING)		{			// keep going round the loop.			return 1;		}		else		{			logp("error in rs_async: %d/n", sigresult);			return -1;		}	}	if(p1b->flags & SBUFL_SEND_ENDOFSIG)	{		iobuf_from_str(&wbuf, CMD_END_FILE, (char *)"endfile");		if(asfd->append_all_to_write_buffer(asfd, &wbuf)) return 1;		p1b->flags &= ~SBUFL_SEND_ENDOFSIG;	}	return 0;}