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

static int fixup_stat(void** param, int param_no){	struct stat_or_pv *sopv;	str s;	long n;	int err;	s.s = (char*)*param;	s.len = strlen(s.s);	if (param_no==1) {		/* var name - string or pv */		sopv = (struct stat_or_pv *)pkg_malloc(sizeof(struct stat_or_pv));		if (sopv==NULL) {			LM_ERR("no more pkg mem/n");			return E_OUT_OF_MEM;		}		memset( sopv, 0 , sizeof(struct stat_or_pv) );		/* is it pv? */		if (s.s[0]=='$') {			if (fixup_pvar(param)!=0) {				LM_ERR("invalid pv %.s as parameter/n",s.s);				return E_CFG;			}			sopv->pv = (pv_spec_t*)(*param);		} else {			/* it is string */			sopv->stat = get_stat( &s );			if (sopv->stat==0) {				LM_ERR("variable <%s> not defined/n", s.s);				return E_CFG;			}		}		pkg_free(s.s);		*param=(void*)sopv;		return 0;	} else if (param_no==2) {		/* update value - integer */		if (s.s[0]=='-' || s.s[0]=='+') {			n = str2s( s.s+1, s.len-1, &err);			if (s.s[0]=='-')				n = -n;		} else {			n = str2s( s.s, s.len, &err);		}		if (err==0){			if (n==0) {				LM_ERR("update with 0 has no sense/n");				return E_CFG;			}			pkg_free(*param);			*param=(void*)n;			return 0;		}else{			LM_ERR("bad update number <%s>/n",(char*)(*param));			return E_CFG;		}	}	return 0;}

// checks the size of the SIM memoryint check_memory(struct modem *mdm, int flag){	char  answer[500];	char* posi;	int   laenge;	int   err,foo;	int   j, out;	for(out=0,j=0;!out && j<10; j++)	{		if (put_command(mdm,"AT+CPMS?/r",9,answer,sizeof(answer),50,0)		&& (posi=strstr(answer,"+CPMS:"))!=0 )		{			// Modem supports CPMS command. Read memory size			if ( (posi=strchr(posi,','))!=0 ) {				posi++;				if ( (laenge=strcspn(posi,",/r"))!=0 ) {					if (flag==USED_MEM ) {						foo = str2s(posi,laenge,&err);						if (err) {							LM_ERR("failed to convert into integer used_memory"									" from CPMS response/n");						} else {							return foo;						}					}					posi+=laenge+1;					if ( (laenge=strcspn(posi,",/r"))!=0 ) {						foo = str2s(posi,laenge,&err);						if (err) {							LM_ERR("failed to convert into integer max_memory"									" from CPMS response/n");						} else {							return foo;						}					}				}			} /* if(strstr) */		} /* if(put_command) */		/* if we are here ->  some error happened */		if (checkmodem(mdm)!=0) {			LM_WARN("something happened with the modem -> was re-init -> let's retry/n");		} else {			LM_ERR("modem seems to be ok, but we had an error? I give up!/n");			out = 1;		}	} /* for */	if (out==0)		LM_ERR("modem does not respond after 10 retries, give up!/n");	return -1;}

static int fixup_maxfwd_header(void** param, int param_no){	unsigned long code;	int err;	if (param_no==1){		code=str2s(*param, strlen(*param), &err);		if (err==0){			if (code<1 || code>MAXFWD_UPPER_LIMIT){				LM_ERR("invalid MAXFWD number <%ld> [1,%d]/n",					code,MAXFWD_UPPER_LIMIT);				return E_UNSPEC;			}			if (code>max_limit) {				LM_ERR("default value <%ld> bigger than max limit(%d)/n",					code, max_limit);				return E_UNSPEC;			}			pkg_free(*param);			*param=(void*)code;			return 0;		}else{			LM_ERR("bad number <%s>/n",(char*)(*param));			return E_UNSPEC;		}	}	return 0;}

int set_network_arg(struct network *net, char *arg, char *arg_end){	int err,foo;	if (*(arg+1)!='=') {		LM_ERR("invalid parameter syntax near [=]/n");		goto error;	}	switch (*arg)	{		case 'm':  /* maximum sms per one call */			foo=str2s(arg+2,arg_end-arg-2,&err);			if (err) {				LM_ERR("cannot convert [m] arg to integer!/n");				goto error;			}			net->max_sms_per_call = foo;			break;		default:			LM_ERR("unknown param name [%c]/n",*arg);			goto error;	}	return 1;error:	return -1;}

/**************************************************************************** * * Function: GetIP(char * iface) * * Purpose: To return a string representing the IP address for an interface * * Arguments: char * iface - The network interface you want to find an IP *            address for. * * Returns: A char * -- make sure you call free on this when you are done *          with it. * ***************************************************************************/char *GetIP(char * iface){    struct ifreq ifr;    struct sockaddr_in *addr;    int s;    if(iface)    {        /* Set up a dummy socket just so we can use ioctl to find the           ip address of the interface */        s = socket(PF_INET, SOCK_DGRAM, 0);        if(s == -1)        {            FatalError("Problem establishing socket to find IP address for interface: %s/n", iface);        }        strncpy(ifr.ifr_name, iface, strlen(iface) + 1);#ifndef WIN32        if(ioctl(s, SIOCGIFADDR, &ifr) < 0) return NULL;        else#endif        {            addr = (struct sockaddr_in *) &ifr.ifr_broadaddr;        }        close(s);        return str2s(inet_ntoa(addr->sin_addr));    }    else    {        return "unknown";    }}

static int fixup_maxfwd_header(void** param, int param_no){	unsigned long code;	int err;	if (param_no==1){		code=str2s(*param, strlen(*param), &err);		if (err==0){			if (code>255){				LOG(L_ERR, "ERROR:maxfwd:fixup_maxfwd_header: "					"number to big <%ld> (max=255)/n",code);				return E_UNSPEC;			}			if ( max_limit && code>max_limit) {				LOG(L_ERR, "ERROR:maxfwd:fixup_maxfwd_header: "					"default value <%ld> bigger than max limit(%d)/n",					code, max_limit);				return E_UNSPEC;			}			pkg_free(*param);			*param=(void*)code;			return 0;		}else{			LOG(L_ERR, "ERROR:maxfwd:fixup_maxfwd_header: bad  number <%s>/n",					(char*)(*param));			return E_UNSPEC;		}	}	return 0;}

static int attr_equals_xl(struct sip_msg* msg, char* p1, char* format){    avp_ident_t* avpid;    avp_value_t avp_val;    struct search_state st;    str xl_val;    avp_t* avp;        avpid = &((fparam_t*)p1)->v.avp;    if (xl_printstr(msg, (xl_elog_t*) format, &xl_val.s, &xl_val.len) > 0) {	for (avp = search_avp(*avpid, &avp_val, &st); avp; avp = search_next_avp(&st, &avp_val)) {	    if (avp->flags & AVP_VAL_STR) {		if ((avp_val.s.len == xl_val.len) &&		    !memcmp(avp_val.s.s, xl_val.s, avp_val.s.len)) return 1;	    } else {		if (avp_val.n == str2s(xl_val.s, xl_val.len, 0)) return 1;	    }	}	return -1;    }        ERR("avp_equals_xl:Error while expanding xl_format/n");    return -1;}

/* looks for the MAX FORWARDS header	* returns its value, -1 if is not present or -2 for error */int is_maxfwd_present( struct sip_msg* msg , str *foo){	int x, err;	/* lookup into the message for MAX FORWARDS header*/	if ( !msg->maxforwards ) {		if  ( parse_headers( msg , HDR_MAXFORWARDS_F, 0 )==-1 ){			LM_ERR("parsing MAX_FORWARD header failed!/n");			return -2;		}		if (!msg->maxforwards) {			LM_DBG("max_forwards header not found!/n");			return -1;		}	} else if (IS_MAXWD_STORED(msg)) {		trim_len( foo->len , foo->s , msg->maxforwards->body );		return FETCH_MAXWD_VAL(msg);	}	/* if header is present, trim to get only the string containing numbers */	trim_len( foo->len , foo->s , msg->maxforwards->body );	/* convert from string to number */	x = str2s( foo->s,foo->len,&err);	if (err){		LM_ERR("unable to parse the max forwards number/n");		return -2;	}	/* store the parsed values */	STORE_MAXWD_VAL(msg, x);	LM_DBG("value = %d /n",x);	return x;}

int get_nr_max(char *s, unsigned char *max){	unsigned short nr;	int err;	if ( s[0]=='*' && s[1]==0 ) {		/* is '*' -> infinit ;-) */		*max = 0;		return 0;	} else {		/* must be a positive number less than 255 */		nr = str2s(s, strlen(s), &err);		if (err==0){			if (nr>255){				LM_ERR("number too big <%d> (max=255)/n",nr);				return -1;			}			*max = (unsigned char)nr;			return 0;		}else{			LM_ERR("bad  number <%s>/n",s);			return -1;		}	}}

/** Get the FR_{INV}_TIMER from corresponding AVP. * @return 0 on success (use *timer) or 1 on failure (avp non-existent, *  avp present  but empty/0, avp value not numeric). */static inline int avp2timer(unsigned int* timer, int type, int_str name){	struct usr_avp *avp;	int_str val_istr;	int err;	avp = search_first_avp(type, name, &val_istr, 0);	if (!avp) {		/*		 DBG("avp2timer: AVP '%.*s' not found/n", param.s->len, ZSW(param.s->s));		 */		return 1;	}		if (avp->flags & AVP_VAL_STR) {		*timer = str2s(val_istr.s.s, val_istr.s.len, &err);		if (err) {			LOG(L_ERR, "avp2timer: Error while converting string to integer/n");			return -1;		}	} else {		*timer = val_istr.n;	}	return *timer==0; /* 1 if 0 (use default), 0 if !=0 (use *timer) */}

/* fixes flag params (resolves possible named flags) * use PARAM_USE_FUNC|PARAM_STRING as a param. type and create * a wrapper function that does just: * return fix_flag(type, val, "my_module", "my_param", &flag_var) * see also param_func_t. */int fix_flag( modparam_t type, void* val,					char* mod_name, char* param_name, int* flag){	int num;	int err;	int f, len;	char* s;	char *p;	if ((type & PARAM_STRING)==0){		LM_CRIT("%s: fix_flag(%s): bad parameter type/n",					mod_name, param_name);		return -1;	}	s=(char*)val;	len=strlen(s);	f=-1;	/* try to see if it's a number */	num = str2s(s, len, &err);	if (err != 0) {		/* see if it's in the name:<no> format */		p=strchr(s, ':');		if (p){			f= str2s(p+1, strlen(p+1), &err);			if (err!=0){				LM_ERR("%s: invalid %s format: /"%s/"",						mod_name, param_name, s);				return -1;			}			*p=0;		}		if ((num=get_flag_no(s, len))<0){			/* not declared yet, declare it */			num=register_flag(s, f);		}		if (num<0){			LM_ERR("%s: bad %s %s/n", mod_name, param_name, s);			return -1;		} else if ((f>0) && (num!=f)){			LM_ERR("%s: flag %s already defined"					" as %d (and not %d), using %s:%d/n",					mod_name, s, num, f, s, num);		}	}	*flag=num;	return 0;}

int update_sock_struct_from_via( union sockaddr_union* to,								 struct sip_msg* msg,								 struct via_body* via ){	struct hostent* he;	str* name;	int err;	unsigned short port;	port=0;	if(via==msg->via1){ 		/* _local_ reply, we ignore any rport or received value		 * (but we will send back to the original port if rport is		 *  present) */		if ((msg->msg_flags&FL_FORCE_RPORT)||(via->rport))			port=msg->rcv.src_port;		else port=via->port;		if(via->maddr)			name= &(via->maddr->value);		else			name=&(via->host); /* received=ip in 1st via is ignored (it's							  not added by us so it's bad) */	}else{		/* "normal" reply, we use rport's & received value if present */		if (via->rport && via->rport->value.s){			LM_DBG("using 'rport'/n");			port=str2s(via->rport->value.s, via->rport->value.len, &err);			if (err){				LM_NOTICE("bad rport value(%.*s)/n",					via->rport->value.len,via->rport->value.s);				port=0;			}		}		if (via->maddr){			name= &(via->maddr->value);			if (port==0) port=via->port?via->port:SIP_PORT; 		} else if (via->received){			LM_DBG("using 'received'/n");			name=&(via->received->value);			/* making sure that we won't do SRV lookup on "received" */			if (port==0) port=via->port?via->port:SIP_PORT; 		}else{			LM_DBG("using via host/n");			name=&(via->host);			if (port==0) port=via->port;		}	}	LM_DBG("trying SRV lookup/n");	he=sip_resolvehost(name, &port, &via->proto, 0, 0);	if (he==0){		LM_NOTICE("resolve_host(%.*s) failure/n", name->len, name->s);		return -1;	}			hostent2su( to, he, 0, port);	return 1;}

/* on digicom the return value can be != sim */static int fetchsms(struct modem *mdm, int sim, char* pdu){	char command[16];	char answer[512];	char* position;	char* beginning;	char* end;	int  foo,err;	int  clen;	// Digicom reports date+time only with AT+CMGL	if (mdm->mode==MODE_DIGICOM) {		put_command(mdm,"AT+CMGL=/"ALL/"/r",14,answer,			sizeof(answer),200,0);		/* search for beginning of the answer */		position=strstr(answer,"+CMGL: ");		if (position) {			end=position+7;			while (*end<'9' && *end>'0') end++;			if (end==position+7) {				foo = str2s(position+7,end-position-7,&err);				if (!err) {					LM_DBG("found a message at memory %i/n",foo);					sim=foo;				}				position = 0;			}			position = 0;		}	} else {		LM_DBG("trying to get stored message %i/n",sim);		clen=sprintf(command,"AT+CMGR=%i/r",sim);		put_command(mdm,command,clen,answer,sizeof(answer),50,0);		/* search for beginning of the answer */		position=strstr(answer,"+CMGR:");	}	/* keine SMS empfangen, weil Modem nicht mit +CMGR	oder +CMGL geantwortet hat */	if (position==0)		return 0;	beginning=position+7;	/* keine SMS, weil Modem mit +CMGR: 0,,0 geantwortet hat */	if (strstr(answer,",,0/r"))		return 0;	/* After that we have the PDU or ASCII string */	for( end=beginning ; *end && *end!='/r' ; end++ );	if ( !*end || end-beginning<4)		return 0;	for( end=end+1 ; *end && *end!='/r' ; end++ );	if ( !*end || end-beginning<4)		return 0;	/* Now we have the end of the PDU or ASCII string */	*end=0;	strcpy(pdu,beginning);	return sim;}

int update_sock_struct_from_via( union sockaddr_union* to,									struct sip_msg* msg,									struct via_body* via ){	struct hostent* he;	str* name;	int err;	unsigned short port;	char proto;	port=0;	if(via==msg->via1){		/* _local_ reply, we ignore any rport or received value		 * (but we will send back to the original port if rport is		 *  present) */		if ((msg->msg_flags&FL_FORCE_RPORT)||(via->rport))			port=msg->rcv.src_port;		else port=via->port;		name=&(via->host); /* received=ip in 1st via is ignored (it's							* not added by us so it's bad) */	}else{		/* "normal" reply, we use rport's & received value if present */		if (via->rport && via->rport->value.s){			LM_DBG("using 'rport'/n");			port=str2s(via->rport->value.s, via->rport->value.len, &err);			if (err){				LM_ERR("bad rport value(%.*s)/n",						via->rport->value.len, via->rport->value.s);				port=0;			}		}		if (via->received){			LM_DBG("using 'received'/n");			name=&(via->received->value);			/* making sure that we won't do SRV lookup on "received"			 * (possible if no DNS_IP_HACK is used)*/			if (port==0) port=via->port?via->port:SIP_PORT;		}else{			LM_DBG("using via host/n");			name=&(via->host);			if (port==0) port=via->port;		}	}	/* we do now a malloc/memcpy because gethostbyname loves /0-terminated	 * strings; but only if host is not null terminated (host.s[len] will	 * always be ok for a via)	 */	LM_DBG("trying SRV lookup/n");	proto=via->proto;	he=sip_resolvehost(name, &port, &proto);	if (he==0){		LM_NOTICE("resolve_host(%.*s) failure/n", name->len, name->s);		return -1;	}	hostent2su(to, he, 0, port);	return 1;}

static union sockaddr_union *jsonrpc_get_dst(str *ip_port){	static union sockaddr_union _su;	struct hostent *hentity;	char *p, bk;	str host;	str port;	int iport;	int err;	if (!ip_port || !ip_port->len) {		LM_ERR("no IP:port specified!/n");		return NULL;	}	/* search for the port */	p = memchr(ip_port->s, ':', ip_port->len);	if (!p) {		LM_ERR("invalid IP:port %.*s/n", ip_port->len, ip_port->s);		return NULL;	}	host.s = ip_port->s;	host.len = p - ip_port->s;	/* remaining should be port */	port.s = p + 1;	port.len = ip_port->len - (host.len + 1/* : */);	trim(&port);	iport = str2s(port.s, port.len, &err);	if (iport <= 0 || err != 0 || iport > 65535) {		LM_ERR("Invalid port specified [%.*s]/n", port.len, port.s);		return NULL;	}	trim(&host);	/* null terminate host */	bk = host.s[host.len];	host.s[host.len] = 0;	hentity = resolvehost(host.s, 0);	host.s[host.len] = bk;	if (!hentity) {		LM_ERR("cannot resolve host %s/n", host.s);		return NULL;	}	if(hostent2su(&_su, hentity, 0, iport)){		LM_ERR("failed to resolve %s/n", host.s);		return NULL;	}		return &_su;}

int mod_register(char *path, int *dlflags, void *p1, void *p2){	str dest = {0};	int ret = 0;	struct sip_uri next_hop, *u;	char *p;	if(_km_log_engine_type==0 || _km_log_engine_data==0)		return 0;	if(strcasecmp(_km_log_engine_type, "udp")!=0)		return 0;	dest.s = _km_log_engine_data;	dest.len = strlen(dest.s);	init_dest_info(&_lc_udp_dst);	u = &next_hop;	u->port_no = 5060;	u->host = dest;	p = dest.s;	/* detect ipv6 */	p = memchr(p, ']', dest.len);	if (p) p++;	else p = dest.s;	p = memchr(p, ':', dest.len - (p - dest.s));	if (p) {		u->host.len = p - dest.s;		p++;		u->port_no = str2s(p, dest.len - (p - dest.s), NULL);	}	ret = sip_hostport2su(&_lc_udp_dst.to, &u->host, u->port_no,			&_lc_udp_dst.proto);	if(ret!=0) {		LM_ERR("failed to resolve [%.*s]/n", u->host.len,				ZSW(u->host.s));		return -1;	}	sr_kemi_modules_add(sr_kemi_log_custom_exports);	return 0;}

static int fixup_sl_send_reply(void** param, int param_no){	unsigned long code;	int err;	if (param_no==1){		code=str2s(*param, strlen(*param), &err);		if (err==0){			pkg_free(*param);			*param=(void*)code;			return 0;		}else{			LOG(L_ERR, "SL module:fixup_sl_send_reply: bad  number <%s>/n",					(char*)(*param));			return E_UNSPEC;		}	}	return 0;}

inline static int fixup_str2int( void** param, int param_no){	unsigned long go_to;	int err;	if (param_no==1) {		go_to=str2s(*param, strlen(*param), &err );		if (err==0) {			pkg_free(*param);			*param=(void *)go_to;			return 0;		} else {			LOG(L_ERR, "ERROR: fixup_str2int: bad number <%s>/n",				(char *)(*param));			return E_CFG;		}	}	return 0;}

inline static int fixup_hostport2proxy(void** param, int param_no){	unsigned int port;	char *host;	int err;	struct proxy_l *proxy;	str s;		DBG("TM module: fixup_t_forward(%s, %d)/n", (char*)*param, param_no);	if (param_no==1){		DBG("TM module: fixup_t_forward: param 1.. do nothing, wait for #2/n");		return 0;	} else if (param_no==2) {		host=(char *) (*(param-1)); 		port=str2s(*param, strlen(*param), &err);		if (err!=0) {			LOG(L_ERR, "TM module:fixup_t_forward: bad port number <%s>/n",				(char*)(*param));			 return E_UNSPEC;		}		s.s = host;		s.len = strlen(host);		proxy=mk_proxy(&s, port, 0); /* FIXME: udp or tcp? */		if (proxy==0) {			LOG(L_ERR, "ERROR: fixup_t_forwardv6: bad host name in URI <%s>/n",				host );			return E_BAD_ADDRESS;		}		/* success -- fix the first parameter to proxy now ! */		/* FIXME: janakj, mk_proxy doesn't make copy of host !! */		/*pkg_free( *(param-1)); you're right --andrei*/		*(param-1)=proxy;		return 0;	} else {		LOG(L_ERR, "ERROR: fixup_t_forwardv6 called with parameter #<>{1,2}/n");		return E_BUG;	}}

/* (char *hostname, char *port_nr) ==> (struct proxy_l *, -)  */static int fixup_hostport2proxy(void** param, int param_no){	unsigned int port;	char *host;	int err;	struct proxy_l *proxy;	action_u_t *a;	str s;	DBG("TM module: fixup_hostport2proxy(%s, %d)/n", (char*)*param, param_no);	if (param_no==1){		return 0;	} else if (param_no==2) {		a = fixup_get_param(param, param_no, 1);		host= a->u.string;		port=str2s(*param, strlen(*param), &err);		if (err!=0) {			LOG(L_ERR, "TM module:fixup_hostport2proxy: bad port number <%s>/n",				(char*)(*param));			 return E_UNSPEC;		}		s.s = host;		s.len = strlen(host);		proxy=mk_proxy(&s, port, 0); /* FIXME: udp or tcp? */		if (proxy==0) {			LOG(L_ERR, "ERROR: fixup_hostport2proxy: bad host name in URI <%s>/n",				host );			return E_BAD_ADDRESS;		}		/* success -- fix the first parameter to proxy now ! */		a->u.data=proxy;		return 0;	} else {		LOG(L_ERR,"ERROR: fixup_hostport2proxy called with parameter #<>{1,2}/n");		return E_BUG;	}}

char* parse_hostport(char* buf, str* host, short int* port){	char *tmp;	int err;	host->s=buf;	for(tmp=buf;(*tmp)&&(*tmp!=':');tmp++);	host->len=tmp-buf;	if (*tmp==0) {		*port=0;	} else {		*tmp=0;		*port=str2s((unsigned char*)(tmp+1), strlen(tmp+1), &err);		if (err ){			LOG(L_INFO, 			    "ERROR: hostport: trailing chars in port number: %s/n",			    tmp+1);			     /* report error? */		}	}	return host->s;}

/* *  returns 1 if msg contains an AVP with the given name and value, *  returns -1 otherwise */static int attr_equals(struct sip_msg* msg, char* p1, char* p2){    avp_ident_t avpid;    int_str value, avp_value;    avp_t* avp;    struct search_state st;    if (get_avp_id(&avpid, (fparam_t*)p1, msg) < 0) {	return -1;    }    if (p2 && get_str_fparam(&value.s, msg, (fparam_t*)p2) < 0) {	ERR("Error while obtaining attribute value from '%s'/n", ((fparam_t*)p2)->orig);	return -1;    }    avp = search_avp(avpid, &avp_value, &st);    if (avp == 0) return -1;    if (!p2) return 1;        while (avp != 0) {	if (avp->flags & AVP_VAL_STR) {	    if ((avp_value.s.len == value.s.len) &&		!memcmp(avp_value.s.s, value.s.s, avp_value.s.len)) {		return 1;	    }	} else {	    if (avp_value.n == str2s(value.s.s, value.s.len, 0)) {		return 1;	    }	}	avp = search_next_avp(&st, &avp_value);    }        return -1;}

/** Initializes seas module. It first parses the listen_sockets parameter * which has the form "ip_address[:port]", creates the pipe to * communicate with the dispatcher. */static int seas_init(void){   char *p,*port;   struct hostent *he;   struct socket_info *si;   int c_pipe[2],mierr,i;   /** Populate seas_functions*/   if (load_tm_api(&seas_f.tmb)!=0) {      LM_ERR( "can't load TM API/n");      return -1;   }   if(!(seas_f.t_check_orig_trans = find_export("t_check_trans", 0, 0))){      LM_ERR( "Seas requires transaction module (t_check_trans not found)/n");      return -1;   }   /** Populate seas_functions*/   c_pipe[0]=c_pipe[1]=-1;   p=seas_listen_socket;   port=(char *)0;   seas_listen_port=5080;   /*if the seas_listen_socket configuration string is empty, use default values*/   if(p==NULL || *p==0){      si=get_first_socket();      seas_listen_ip=&si->address;   } else {/*if config string is not empty, then try to find host first, and maybe port..*/      while(*p){	 if(*p == ':'){	    *p=0;	    port=p+1;	    break;	 }	 p++;      }      if(!(he=resolvehost(seas_listen_socket,0)))	 goto error;      if(!(seas_listen_ip=pkg_malloc(sizeof(struct ip_addr))))	 goto error;      hostent2ip_addr(seas_listen_ip, he, 0);      if(port!=(char *)0 && (seas_listen_port=str2s(port,strlen(port),&mierr))==0){	 LM_ERR("invalid port %s /n",port);	 goto error;      }   }   memset(unc_as_t,0,2*MAX_UNC_AS_NR*sizeof(struct unc_as));//useless because unc_as_t is in bss?   if (pipe(c_pipe)==-1) {      LM_ERR("cannot create pipe!/n");      goto error;   }   read_pipe=c_pipe[0];   write_pipe=c_pipe[1];   seas_init_tags();   if(0>start_stats_server(seas_stats_socket))      goto error;   if(0>prepare_ha())      goto error;   if(0>parse_cluster_cfg())      goto error;   return 0;error:   for(i=0;i<2;i++)      if(c_pipe[i]!=-1)	 close(c_pipe[i]);   if(seas_listen_ip!=0)      pkg_free(seas_listen_ip);   if(use_stats)      stop_stats_server();   return -1;}

//.........这里部分代码省略.........							goto parse_error;						break;					case F_CRLF:					case F_LF:					case F_CR:						/*previous=crlf and now !=' '*/						goto endofheader;					default:						LM_CRIT("invalid char <%c> in state %d/n",*tmp, state);						goto parse_error;				}		}	}	LM_DBG("end of packet reached, state=%d/n", state);	goto endofpacket; /*end of packet, probably should be goto error*/	endofheader:	state=saved_state;	LM_DBG("end of header reached, state=%d/n", state);endofpacket:	/* check if error*/	switch(state){		case P_HOST:		case L_PORT:		case P_PORT:		case L_PARAM:		case P_PARAM:		case P_VALUE:		case GEN_PARAM:		case FIN_HIDDEN:		case L_VIA:			break;		default:			LM_ERR(" invalid via - end of header in state %d/n", state);			goto parse_error;	}	/*	if (proto) printf("<SIP/2.0/%s>/n", proto);	if (host) printf("host= <%s>/n", host);	if (port_str) printf("port= <%s>/n", port_str);	if (param) printf("params= <%s>/n", param);	if (comment) printf("comment= <%s>/n", comment);	if(next_via) printf("next_via= <%s>/n", next_via);	*/	/*LM_DBG("rest=<%s>/n", tmp);*/	vb->error=PARSE_OK;	vb->bsize=tmp-buffer;	if (vb->port_str.s){		vb->port=str2s(vb->port_str.s, vb->port_str.len, &err);		if (err){					LM_ERR(" invalid port number <%.*s>/n",						vb->port_str.len, ZSW(vb->port_str.s));					goto parse_error;		}	}	return tmp;nextvia:	LM_DBG("next_via/n");	vb->error=PARSE_OK;	vb->bsize=tmp-buffer;	if (vb->port_str.s){		vb->port=str2s(vb->port_str.s, vb->port_str.len, &err);		if (err){					LM_ERR(" invalid port number <%.*s>/n",						vb->port_str.len, ZSW(vb->port_str.s));					goto parse_error;		}	}	vb->next=pkg_malloc(sizeof(struct via_body));	if (vb->next==0){		LM_ERR(" out of pkg memory/n");		goto error;	}	vb=vb->next;	memset(vb, 0, sizeof(struct via_body));	buffer=tmp;	goto parse_again;parse_error:	if (end>buffer){		LM_ERR(" <%.*s>/n", (int)(end-buffer), ZSW(buffer));	}	if ((tmp>buffer)&&(tmp<end)){		LM_ERR("parsed so far:<%.*s>/n",				(int)(tmp-buffer), ZSW(buffer) );	}else{		LM_ERR("via parse failed/n");	}error:	vb->error=PARSE_ERROR;	vbody->error=PARSE_ERROR; /* make sure the first via body is marked								 as bad also */	return tmp;}

int corex_send(sip_msg_t *msg, gparam_t *pu, enum sip_protos proto){	str dest = {0};	int ret = 0;	struct sip_uri next_hop, *u;	struct dest_info dst;	char *p;	if (pu)	{		if (fixup_get_svalue(msg, pu, &dest))		{			LM_ERR("cannot get the destination parameter/n");			return -1;		}	}	init_dest_info(&dst);	if (dest.len <= 0)	{		/*get next hop uri uri*/		if (msg->dst_uri.len) {			ret = parse_uri(msg->dst_uri.s, msg->dst_uri.len,							&next_hop);			u = &next_hop;		} else {			ret = parse_sip_msg_uri(msg);			u = &msg->parsed_uri;		}		if (ret<0) {			LM_ERR("send() - bad_uri dropping packet/n");			ret=E_BUG;			goto error;		}	} else {		u = &next_hop;		u->port_no = 5060;		u->host = dest;		/* detect ipv6 */		p = memchr(dest.s, ']', dest.len);		if (p) {			p++;			p = memchr(p, ':', dest.s + dest.len - p);		} else {			p = memchr(dest.s, ':', dest.len);		}		if (p)		{			u->host.len = p - dest.s;			p++;			u->port_no = str2s(p, dest.len - (p - dest.s), NULL);		}	}	ret = sip_hostport2su(&dst.to, &u->host, u->port_no,				&dst.proto);	if(ret!=0) {		LM_ERR("failed to resolve [%.*s]/n", u->host.len,			ZSW(u->host.s));		ret=E_BUG;		goto error;	}	dst.proto = proto;	if (proto == PROTO_UDP)	{		dst.send_sock=get_send_socket(msg, &dst.to, PROTO_UDP);		if (dst.send_sock!=0){			ret=udp_send(&dst, msg->buf, msg->len);		}else{			ret=-1;		}	}#ifdef USE_TCP	else{		/*tcp*/		dst.id=0;		ret=tcp_send(&dst, 0, msg->buf, msg->len);	}#endif	if (ret>=0) ret=1;error:	return ret;}

int corex_add_alias_subdomains(char* aliasval){	char *p = NULL;	corex_alias_t ta;	corex_alias_t *na;	memset(&ta, 0, sizeof(corex_alias_t));	p = strchr(aliasval, ':');	if(p==NULL) {		/* only hostname */		ta.alias.s = aliasval;		ta.alias.len = strlen(aliasval);		goto done;	}	if((p-aliasval)==3 || (p-aliasval)==4) {		/* check if it is protocol */		if((p-aliasval)==3 && strncasecmp(aliasval, "udp", 3)==0) {			ta.proto = PROTO_UDP;		} else if((p-aliasval)==3 && strncasecmp(aliasval, "tcp", 3)==0) {			ta.proto = PROTO_TCP;		} else if((p-aliasval)==3 && strncasecmp(aliasval, "tls", 3)==0) {			ta.proto = PROTO_TLS;		} else if((p-aliasval)==4 && strncasecmp(aliasval, "sctp", 4)==0) {			ta.proto = PROTO_SCTP;		} else {			/* use hostname */			ta.alias.s = aliasval;			ta.alias.len = p - aliasval;		}	}	if(ta.alias.len==0) {		p++;		if(p>=aliasval+strlen(aliasval))			goto error;		ta.alias.s = p;		p = strchr(ta.alias.s, ':');		if(p==NULL) {			ta.alias.len = strlen(ta.alias.s);			goto done;		}	}	/* port */	p++;	if(p>=aliasval+strlen(aliasval))		goto error;	ta.port = str2s(p, strlen(p), NULL);done:	if(ta.alias.len==0)		goto error;	na = (corex_alias_t*)pkg_malloc(sizeof(corex_alias_t));	if(na==NULL) {		LM_ERR("no memory for adding alias subdomains: %s/n", aliasval);		return -1;	}	memcpy(na, &ta, sizeof(corex_alias_t));	na->next = _corex_alias_list;	_corex_alias_list = na;	return 0;error:	LM_ERR("error adding alias subdomains: %s/n", aliasval);	return -1;}