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

//.........这里部分代码省略.........  /* Allocate output structures. */  if ( ( output->a = (REAL4TimeVectorSeries *)	 LALMalloc( sizeof(REAL4TimeVectorSeries) ) ) == NULL ) {    ABORT( stat, GENERATESPINORBITCWH_EMEM,	   GENERATESPINORBITCWH_MSGEMEM );  }  memset( output->a, 0, sizeof(REAL4TimeVectorSeries) );  if ( ( output->f = (REAL4TimeSeries *)	 LALMalloc( sizeof(REAL4TimeSeries) ) ) == NULL ) {    LALFree( output->a ); output->a = NULL;    ABORT( stat, GENERATESPINORBITCWH_EMEM,	   GENERATESPINORBITCWH_MSGEMEM );  }  memset( output->f, 0, sizeof(REAL4TimeSeries) );  if ( ( output->phi = (REAL8TimeSeries *)	 LALMalloc( sizeof(REAL8TimeSeries) ) ) == NULL ) {    LALFree( output->a ); output->a = NULL;    LALFree( output->f ); output->f = NULL;    ABORT( stat, GENERATESPINORBITCWH_EMEM,	   GENERATESPINORBITCWH_MSGEMEM );  }  memset( output->phi, 0, sizeof(REAL8TimeSeries) );  /* Set output structure metadata fields. */  output->position = params->position;  output->psi = params->psi;  output->a->epoch = output->f->epoch = output->phi->epoch    = params->epoch;  output->a->deltaT = n*params->deltaT;  output->f->deltaT = output->phi->deltaT = params->deltaT;  output->a->sampleUnits = lalStrainUnit;  output->f->sampleUnits = lalHertzUnit;  output->phi->sampleUnits = lalDimensionlessUnit;  snprintf( output->a->name, LALNameLength, "CW amplitudes" );  snprintf( output->f->name, LALNameLength, "CW frequency" );  snprintf( output->phi->name, LALNameLength, "CW phase" );  /* Allocate phase and frequency arrays. */  LALSCreateVector( stat->statusPtr, &( output->f->data ), n );  BEGINFAIL( stat ) {    LALFree( output->a );   output->a = NULL;    LALFree( output->f );   output->f = NULL;    LALFree( output->phi ); output->phi = NULL;  } ENDFAIL( stat );  LALDCreateVector( stat->statusPtr, &( output->phi->data ), n );  BEGINFAIL( stat ) {    TRY( LALSDestroyVector( stat->statusPtr, &( output->f->data ) ),	 stat );    LALFree( output->a );   output->a = NULL;    LALFree( output->f );   output->f = NULL;    LALFree( output->phi ); output->phi = NULL;  } ENDFAIL( stat );  /* Allocate and fill amplitude array. */  {    CreateVectorSequenceIn in; /* input to create output->a */    in.length = 2;    in.vectorLength = 2;    LALSCreateVectorSequence( stat->statusPtr, &(output->a->data), &in );    BEGINFAIL( stat ) {      TRY( LALSDestroyVector( stat->statusPtr, &( output->f->data ) ),	   stat );      TRY( LALDDestroyVector( stat->statusPtr, &( output->phi->data ) ),	   stat );      LALFree( output->a );   output->a = NULL;      LALFree( output->f );   output->f = NULL;

char *get_running_state_fname(const char *ve_private, char *buf, int size){	snprintf(buf, size, "%s/.running", ve_private);	return buf;}

/** Register Container * @param path		Container private data root * @param param		struct vzctl_reg_param * @param flags		registration flags * @return		veid or -1 in case error */int vzctl2_env_register(const char *path, struct vzctl_reg_param *param, int flags){	char buf[PATH_MAX];	char veconf[STR_SIZE];	char path_r[PATH_MAX];	struct stat st;	int ret, err;	struct vzctl_env_handle *h;	FILE *fp;	char ve_host[STR_SIZE];	char host[STR_SIZE];	int owner_check_res;	int on_pcs, on_shared;	int ha_resource_added = 0;	int ha_enable = 0;	const char *data, *name;	ctid_t ctid = {};	ctid_t uuid = {};	/* preserve compatibility	 * VZ_REG_SKIP_HA_CLUSTER is alias for VZ_REG_SKIP_CLUSTER	 */	if (flags & VZ_REG_SKIP_HA_CLUSTER)		flags |= VZ_REG_SKIP_CLUSTER;	if (stat(path, &st) != 0)		return vzctl_err(-1, errno, "Unable to stat %s", path);	if (realpath(path, path_r) == NULL)		return vzctl_err(-1, errno, "Failed to get realpath %s", path);	ret = vzctl2_env_layout_version(path_r);	if (ret == -1) {		return -1;	} else if (ret < VZCTL_LAYOUT_4)		return vzctl_err(-1, 0, "Warning: Container in old data format,"				" registration skipped.");	snprintf(veconf, sizeof(veconf), "%s/" VZCTL_VE_CONF, path_r);	if (stat(veconf, &st)) {		logger(-1, 0, "Error: Broken Container, no %s file found", veconf);		return -1;	}	h = vzctl2_env_open_conf(param->ctid, veconf, 0, &err);	if (h == NULL)		return -1;	data = param->uuid;	/* get UUID from config if not specified */	if (data == NULL)		vzctl2_env_get_param(h, "UUID", &data);	if (get_cid_uuid_pair(param->ctid, data, ctid, uuid))		goto err;	owner_check_res = vzctl_check_owner_quiet(			path_r, host, sizeof(host), ve_host, sizeof(ve_host));	on_pcs = (is_pcs(path_r) == 1);	on_shared = (is_shared_fs(path_r) == 1);        if (vzctl2_env_get_param(h, "HA_ENABLE", &data) == 0 && data != NULL)                ha_enable = yesno2id(data);	if (on_pcs && ha_enable != VZCTL_PARAM_OFF &&			check_external_disk(path_r, h->env_param->disk) &&			shaman_is_configured())	{		logger(-1, 0, "Containers with external disks cannot be"				" registered in a High Availability cluster");		goto err;	}	if (!(flags & VZ_REG_FORCE)) {		/* ignore renew option for pstorage (https://jira.sw.ru/browse/PSBM-16819) */		if (on_pcs)			flags &= ~VZ_REG_RENEW;		if (!(flags & VZ_REG_RENEW) && owner_check_res) {			if (owner_check_res == VZCTL_E_ENV_MANAGE_DISABLED) {				logger(-1, 0, "Owner check failed on the server %s;"					" Container is registered for %s", host, ve_host);				if (on_pcs)					logger(0, 0,					"Failed to register the Container/virtual machine. "					"You can force the registration, but this will revoke "					"all access to the Container from the original server.");			}			goto err;		}		if (validate_eid(h, &st, ctid))			goto err;	} else if ((owner_check_res == VZCTL_E_ENV_MANAGE_DISABLED) && on_shared) {//.........这里部分代码省略.........

void CGPS9_23LogPosition (uint8_t vl_index, uint32_t Status_Code, s_GN_GPS_Nav_Data *pl_nav_data_to_use){#if defined( CMCC_LOGGING_ENABLE ) && defined( AGPS_UP_FTR )    int8_t Session_Start[20], Session_End[20];    switch( Status_Code )    {        case CGPS_SUPL_CMCC_AGPS_SESSION_STARTED:           sprintf( (char*)Session_Start , "%d" , 0 );           GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_AGPS_SESSION_STARTED , Session_Start , "session starts");        break;        case CGPS_SUPL_CMCC_REPONSE_TIMEOUT_CODE:            if (pl_nav_data_to_use != NULL)            {                if(pl_nav_data_to_use->Valid_SingleFix || pl_nav_data_to_use->Valid_SingleFix)                {                    /*we have a fix but don't reach the quality*/                    sprintf( s_CmccLog, "%i, %04d%02d%02d%02d%02d%02d.%03d, %f, %f, %f, %f, # Position(Timestamp, lat, lon, orientation, height)  time to fix : %ld ms",                        s_CgpsSupl[vl_index].v_GPSHandle, pl_nav_data_to_use->Year, pl_nav_data_to_use->Month,                        pl_nav_data_to_use->Day, pl_nav_data_to_use->Hours, pl_nav_data_to_use->Minutes,                        pl_nav_data_to_use->Seconds, pl_nav_data_to_use->Milliseconds,                        pl_nav_data_to_use->Latitude, pl_nav_data_to_use->Longitude,                        pl_nav_data_to_use->CourseOverGround, pl_nav_data_to_use->Altitude_MSL,                        GN_GPS_Get_OS_Time_ms()-s_CgpsNaf[vl_index].v_RegisterTime);                    GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_REPONSE_TIMEOUT_CODE, (char*)s_CmccLog, CGPS_SUPL_CMCC_POSITION_QUALITY_NOT_REACHED_STRING);                }                else                {                    /*no fix*/                    snprintf( s_CmccLog,CGPS_SUPL_CMCC_STRING_MAX_LENGHT-1, "%i",s_CgpsSupl[vl_index].v_GPSHandle);                    GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_REPONSE_TIMEOUT_CODE, (char*)s_CmccLog, CGPS_SUPL_CMCC_CANNOT_PRODUCE_POSITION_WITHIN_RESP_TIME_STRING);                }            }            else            {                sprintf( s_CmccLog, "%i, %04d%02d%02d%02d%02d%02d.%03d, %f, %f, %f, %f, # Position(Timestamp, lat, lon, orientation, height)  time to fix : %ld ms",                    s_CgpsSupl[vl_index].v_GPSHandle, vg_Nav_Data.Year, vg_Nav_Data.Month,                    vg_Nav_Data.Day, vg_Nav_Data.Hours, vg_Nav_Data.Minutes,                    vg_Nav_Data.Seconds, vg_Nav_Data.Milliseconds,                    vg_Nav_Data.Latitude, vg_Nav_Data.Longitude,                    vg_Nav_Data.CourseOverGround, vg_Nav_Data.Altitude_MSL,                    GN_GPS_Get_OS_Time_ms()-s_CgpsSupl[vl_index].v_RegisterTime);                GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_REPONSE_TIMEOUT_CODE, (char*)s_CmccLog, NULL);            }        break;        case CGPS_SUPL_CMCC_POSITION_RESULT_CODE:            if (pl_nav_data_to_use != NULL)            {                sprintf( s_CmccLog, "%i, %04d%02d%02d%02d%02d%02d.%03d, %f, %f, %f, %f, # Position(Timestamp, lat, lon, orientation, height)  time to fix : %ld ms",                    s_CgpsSupl[vl_index].v_GPSHandle, pl_nav_data_to_use->Year, pl_nav_data_to_use->Month,                    pl_nav_data_to_use->Day, pl_nav_data_to_use->Hours, pl_nav_data_to_use->Minutes,                    pl_nav_data_to_use->Seconds, pl_nav_data_to_use->Milliseconds,                    pl_nav_data_to_use->Latitude, pl_nav_data_to_use->Longitude,                    pl_nav_data_to_use->CourseOverGround, pl_nav_data_to_use->Altitude_MSL,                    GN_GPS_Get_OS_Time_ms()-s_CgpsNaf[vl_index].v_RegisterTime);                GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_POSITION_RESULT_CODE, (char*)s_CmccLog, NULL);            }        break;        case CGPS_SUPL_CMCC_NETWORKCONNECTION_CODE:            snprintf(s_CmccLog, CGPS_SUPL_CMCC_STRING_MAX_LENGHT-1, "%i",s_CgpsSupl[vl_index].v_GPSHandle);            GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_NETWORKCONNECTION_CODE,(char*)s_CmccLog,CGPS_SUPL_CMCC_NETWORKCONNECTION_STRING);        break;        case CGPS_SUPL_CMCC_NO_NETWORKCONNECTION_CODE:            if (vl_index == 0xFF)            {                snprintf(s_CmccLog, CGPS_SUPL_CMCC_STRING_MAX_LENGHT-1, "%x", 0xFFFFFFFF);                GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_NO_NETWORKCONNECTION_CODE, (char*)s_CmccLog, CGPS_SUPL_CMCC_AUTONOMOUS_SET_STRING);            }            else            {                snprintf(s_CmccLog, CGPS_SUPL_CMCC_STRING_MAX_LENGHT-1,"%i",s_CgpsSupl[vl_index].v_GPSHandle);                GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_NO_NETWORKCONNECTION_CODE, (char*)s_CmccLog, CGPS_SUPL_CMCC_NO_NETWORKCONNECTION_STRING);            }        break;        case CGPS_SUPL_CMCC_NETWORKCONNECTION_FAILURE_CODE:            snprintf(s_CmccLog, CGPS_SUPL_CMCC_STRING_MAX_LENGHT-1, "%i",s_CgpsSupl[vl_index].v_GPSHandle);            GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_NETWORKCONNECTION_FAILURE_CODE, (char*)s_CmccLog, CGPS_SUPL_CMCC_NETWORKCONNECTION_FAILURE_STRING);        break;        case CGPS_SUPL_CMCC_SERVERCONNECTION_CODE:            snprintf(s_CmccLog, CGPS_SUPL_CMCC_STRING_MAX_LENGHT-1, "%i",s_CgpsSupl[vl_index].v_GPSHandle);            GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_SERVERCONNECTION_CODE,(char*)s_CmccLog,CGPS_SUPL_CMCC_SERVERCONNECTION_STRING);        break;        case CGPS_SUPL_CMCC_SERVERCONNECTION_FAILURE_CODE:            snprintf(s_CmccLog, CGPS_SUPL_CMCC_STRING_MAX_LENGHT-1, "%i",s_CgpsSupl[vl_index].v_GPSHandle);            GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_SERVERCONNECTION_FAILURE_CODE,(char*)s_CmccLog,CGPS_SUPL_CMCC_SERVERCONNECTION_FAILURE_STRING);        break;        case CGPS_SUPL_CMCC_AGPS_SESSION_ENDED:           sprintf( (char*)Session_End , "%d" , 0 );           GN_SUPL_Write_Event_Log_CMCC(CGPS_SUPL_CMCC_AGPS_SESSION_STARTED , Session_End , "session ends");        break;//.........这里部分代码省略.........

/*********************************************************************CREATE TABLE T( 	c1 VARCHAR(n),       	c2 INT NOT NULL,       	c3 FLOAT,       	c4 DOUBLE,       	c5 BLOB,	c6 DECIMAL,	PK(c1));  */staticib_err_tcreate_table(/*=========*/	const char*	dbname,			/*!< in: database name */	const char*	name)			/*!< in: table name */{	ib_trx_t	ib_trx;	ib_id_t		table_id = 0;	ib_err_t	err = DB_SUCCESS;	ib_tbl_sch_t	ib_tbl_sch = NULL;	ib_idx_sch_t	ib_idx_sch = NULL;	char		table_name[IB_MAX_TABLE_NAME_LEN];#ifdef __WIN__	sprintf(table_name, "%s/%s", dbname, name);#else	snprintf(table_name, sizeof(table_name), "%s/%s", dbname, name);#endif	/* Pass a table page size of 0, ie., use default page size. */	err = ib_table_schema_create(		table_name, &ib_tbl_sch, IB_TBL_COMPACT, 0);	assert(err == DB_SUCCESS);	err = ib_table_schema_add_col(		ib_tbl_sch, "c1", IB_VARCHAR, IB_COL_NONE, 0, 10);	assert(err == DB_SUCCESS);	err = ib_table_schema_add_col(		ib_tbl_sch, "c2", IB_INT, IB_COL_NOT_NULL, 0, sizeof(ib_u32_t));	assert(err == DB_SUCCESS);	err = ib_table_schema_add_col(		ib_tbl_sch, "c3", IB_FLOAT, IB_COL_NONE, 0, sizeof(float));	assert(err == DB_SUCCESS);	err = ib_table_schema_add_col(		ib_tbl_sch, "c4", IB_DOUBLE, IB_COL_NONE, 0, sizeof(double));	assert(err == DB_SUCCESS);	err = ib_table_schema_add_col(		ib_tbl_sch, "c5", IB_BLOB, IB_COL_NONE, 0, 0);	assert(err == DB_SUCCESS);	err = ib_table_schema_add_col(		ib_tbl_sch, "c6", IB_DECIMAL, IB_COL_NONE, 0, 0);	assert(err == DB_SUCCESS);	err = ib_table_schema_add_index(ib_tbl_sch, "PRIMARY", &ib_idx_sch);	assert(err == DB_SUCCESS);	/* Set prefix length to 0. */	err = ib_index_schema_add_col( ib_idx_sch, "c1", 0);	assert(err == DB_SUCCESS);	err = ib_index_schema_set_clustered(ib_idx_sch);	assert(err == DB_SUCCESS);	/* create table */	ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ);	err = ib_schema_lock_exclusive(ib_trx);	assert(err == DB_SUCCESS);	err = ib_table_create(ib_trx, ib_tbl_sch, &table_id);	assert(err == DB_SUCCESS);	err = ib_trx_commit(ib_trx);	assert(err == DB_SUCCESS);	if (ib_tbl_sch != NULL) {		ib_table_schema_delete(ib_tbl_sch);	}	return(err);}

static ssize_t dbg_mask_show(struct device *d,		struct device_attribute *attr, char *buf){	return snprintf(buf, PAGE_SIZE, "%d/n", data_msg_dbg_mask);}

//.........这里部分代码省略.........	 */	if (data[3])		state->cur_dive->duration.seconds = atoi(data[3]);	if (data[15])		state->cur_dive->dc.duration.seconds = atoi(data[15]);	/*	 * TODO: the deviceid hash should be calculated here.	 */	settings_start(state);	dc_settings_start(state);	if (data[4])		utf8_string(data[4], &state->cur_settings.dc.serial_nr);	if (data[5])		utf8_string(data[5], &state->cur_settings.dc.model);	state->cur_settings.dc.deviceid = 0xffffffff;	dc_settings_end(state);	settings_end(state);	if (data[6])		state->cur_dive->dc.maxdepth.mm = lrint(strtod_flags(data[6], NULL, 0) * 1000);	if (data[8])		state->cur_dive->dc.airtemp.mkelvin = C_to_mkelvin(atoi(data[8]));	if (data[9])		state->cur_dive->dc.watertemp.mkelvin = C_to_mkelvin(atoi(data[9]));	/*	 * TODO: handle multiple cylinders	 */	cylinder_start(state);	if (data[22] && atoi(data[22]) > 0)		state->cur_dive->cylinder[state->cur_cylinder_index].start.mbar = atoi(data[22]);	else if (data[10] && atoi(data[10]) > 0)		state->cur_dive->cylinder[state->cur_cylinder_index].start.mbar = atoi(data[10]);	if (data[23] && atoi(data[23]) > 0)		state->cur_dive->cylinder[state->cur_cylinder_index].end.mbar = (atoi(data[23]));	if (data[11] && atoi(data[11]) > 0)		state->cur_dive->cylinder[state->cur_cylinder_index].end.mbar = (atoi(data[11]));	if (data[12])		state->cur_dive->cylinder[state->cur_cylinder_index].type.size.mliter = lrint((strtod_flags(data[12], NULL, 0)) * 1000);	if (data[13])		state->cur_dive->cylinder[state->cur_cylinder_index].type.workingpressure.mbar = (atoi(data[13]));	if (data[20])		state->cur_dive->cylinder[state->cur_cylinder_index].gasmix.o2.permille = atoi(data[20]) * 10;	if (data[21])		state->cur_dive->cylinder[state->cur_cylinder_index].gasmix.he.permille = atoi(data[21]) * 10;	cylinder_end(state);	if (data[14])		state->cur_dive->dc.surface_pressure.mbar = (atoi(data[14]) * 1000);	interval = data[16] ? atoi(data[16]) : 0;	profileBlob = (float *)data[17];	tempBlob = (unsigned char *)data[18];	pressureBlob = (int *)data[19];	for (i = 0; interval && i * interval < state->cur_dive->duration.seconds; i++) {		sample_start(state);		state->cur_sample->time.seconds = i * interval;		if (profileBlob)			state->cur_sample->depth.mm = lrintf(profileBlob[i] * 1000.0f);		else			state->cur_sample->depth.mm = state->cur_dive->dc.maxdepth.mm;		if (data[18] && data[18][0])			state->cur_sample->temperature.mkelvin = C_to_mkelvin(tempBlob[i]);		if (data[19] && data[19][0])			state->cur_sample->pressure[0].mbar = pressureBlob[i];		sample_end(state);	}	snprintf(get_events, sizeof(get_events) - 1, get_events_template, state->cur_dive->number);	retval = sqlite3_exec(handle, get_events, &dm4_events, state, &err);	if (retval != SQLITE_OK) {		fprintf(stderr, "%s", "Database query dm4_events failed./n");		return 1;	}	snprintf(get_events, sizeof(get_events) - 1, get_tags_template, state->cur_dive->number);	retval = sqlite3_exec(handle, get_events, &dm4_tags, state, &err);	if (retval != SQLITE_OK) {		fprintf(stderr, "%s", "Database query dm4_tags failed./n");		return 1;	}	dive_end(state);	/*	for (i=0; i<columns;++i) {		fprintf(stderr, "%s/t", column[i]);	}	fprintf(stderr, "/n");	for (i=0; i<columns;++i) {		fprintf(stderr, "%s/t", data[i]);	}	fprintf(stderr, "/n");	//exit(0);	*/	return SQLITE_OK;}

// pretty print elapsed (or estimated) number of secondsstatic void time_string(uint32_t time, int est, char *buf, size_t len){  	int y = time / 31556736;  	int d = (time % 31556736) / 86400;	int h = (time % 86400) / 3600;	int m = (time % 3600) / 60;	int s = time % 60;	if (est) {		if (y > 0) {			snprintf(buf, len, "%d years", y);		} else if (d > 9) {			snprintf(buf, len, "%dd", d);		} else if (d > 0) {			snprintf(buf, len, "%dd%02dh", d, h);		} else if (h > 9) {			snprintf(buf, len, "%dh", h);		} else if (h > 0) {			snprintf(buf, len, "%dh%02dm", h, m);		} else if (m > 9) {			snprintf(buf, len, "%dm", m);		} else if (m > 0) {			snprintf(buf, len, "%dm%02ds", m, s);		} else {			snprintf(buf, len, "%ds", s);		}	} else {		if (d > 0) {			snprintf(buf, len, "%dd%d:%02d:%02d", d, h, m, s);		} else if (h > 0) {			snprintf(buf, len, "%d:%02d:%02d", h, m, s);		} else {			snprintf(buf, len, "%d:%02d", m, s);		}	}}

// TODO: use esil here?R_API char *r_anal_op_to_string(RAnal *anal, RAnalOp *op) {	RAnalFunction *f;	char ret[128];	char *cstr;	char *r0 = r_anal_value_to_string (op->dst);	char *a0 = r_anal_value_to_string (op->src[0]);	char *a1 = r_anal_value_to_string (op->src[1]);	switch (op->type) {	case R_ANAL_OP_TYPE_MOV:		snprintf (ret, sizeof (ret), "%s = %s", r0, a0);		break;	case R_ANAL_OP_TYPE_CJMP:		{		RAnalBlock *bb = r_anal_bb_from_offset (anal, op->addr);		if (bb) {			cstr = r_anal_cond_to_string (bb->cond);			snprintf (ret, sizeof (ret), "if (%s) goto 0x%"PFMT64x, cstr, op->jump);			free (cstr);		} else snprintf (ret, sizeof (ret), "if (%s) goto 0x%"PFMT64x, "unk", op->jump);		}		break;	case R_ANAL_OP_TYPE_JMP:		snprintf (ret, sizeof (ret), "goto 0x%"PFMT64x, op->jump);		break;	case R_ANAL_OP_TYPE_UJMP:		snprintf (ret, sizeof (ret), "goto %s", r0);		break;	case R_ANAL_OP_TYPE_PUSH:	case R_ANAL_OP_TYPE_UPUSH:		snprintf (ret, sizeof (ret), "push %s", a0);		break;	case R_ANAL_OP_TYPE_POP:		snprintf (ret, sizeof (ret), "pop %s", r0);		break;	case R_ANAL_OP_TYPE_UCALL:		snprintf (ret, sizeof (ret), "%s()", r0);		break;	case R_ANAL_OP_TYPE_CALL:		f = r_anal_get_fcn_in (anal, op->jump, R_ANAL_FCN_TYPE_NULL);		if (f) snprintf (ret, sizeof (ret), "%s()", f->name);		else  snprintf (ret, sizeof (ret), "0x%"PFMT64x"()", op->jump);		break;	case R_ANAL_OP_TYPE_CCALL:		f = r_anal_get_fcn_in (anal, op->jump, R_ANAL_FCN_TYPE_NULL);		{		RAnalBlock *bb = r_anal_bb_from_offset (anal, op->addr);		if (bb) {			cstr = r_anal_cond_to_string (bb->cond);			if (f) snprintf (ret, sizeof (ret), "if (%s) %s()", cstr, f->name);			else snprintf (ret, sizeof (ret), "if (%s) 0x%"PFMT64x"()", cstr, op->jump);			free (cstr);		} else {			if (f) snprintf (ret, sizeof (ret), "if (unk) %s()", f->name);			else snprintf (ret, sizeof (ret), "if (unk) 0x%"PFMT64x"()", op->jump);		}		}		break;	case R_ANAL_OP_TYPE_ADD:		if (a1 == NULL || !strcmp (a0, a1))			snprintf (ret, sizeof (ret), "%s += %s", r0, a0);		else snprintf (ret, sizeof (ret), "%s = %s + %s", r0, a0, a1);		break;	case R_ANAL_OP_TYPE_SUB:		if (a1 == NULL || !strcmp (a0, a1))			snprintf (ret, sizeof (ret), "%s -= %s", r0, a0);		else snprintf (ret, sizeof (ret), "%s = %s - %s", r0, a0, a1);		break;	case R_ANAL_OP_TYPE_MUL:		if (a1 == NULL || !strcmp (a0, a1))			snprintf (ret, sizeof (ret), "%s *= %s", r0, a0);		else snprintf (ret, sizeof (ret), "%s = %s * %s", r0, a0, a1);		break;	case R_ANAL_OP_TYPE_DIV:		if (a1 == NULL || !strcmp (a0, a1))			snprintf (ret, sizeof (ret), "%s /= %s", r0, a0);		else snprintf (ret, sizeof (ret), "%s = %s / %s", r0, a0, a1);		break;	case R_ANAL_OP_TYPE_AND:		if (a1 == NULL || !strcmp (a0, a1))			snprintf (ret, sizeof (ret), "%s &= %s", r0, a0);		else snprintf (ret, sizeof (ret), "%s = %s & %s", r0, a0, a1);		break;	case R_ANAL_OP_TYPE_OR:		if (a1 == NULL || !strcmp (a0, a1))			snprintf (ret, sizeof (ret), "%s |= %s", r0, a0);		else snprintf (ret, sizeof (ret), "%s = %s | %s", r0, a0, a1);		break;	case R_ANAL_OP_TYPE_XOR:		if (a1 == NULL || !strcmp (a0, a1))			snprintf (ret, sizeof (ret), "%s ^= %s", r0, a0);		else snprintf (ret, sizeof (ret), "%s = %s ^ %s", r0, a0, a1);		break;	case R_ANAL_OP_TYPE_LEA:		snprintf (ret, sizeof (ret), "%s -> %s", r0, a0);		break;	case R_ANAL_OP_TYPE_CMP:		memcpy (ret, ";", 2);		break;//.........这里部分代码省略.........

xml_element* XMLRPC_to_xml_element_worker(XMLRPC_VALUE current_vector, XMLRPC_VALUE node,                                           XMLRPC_REQUEST_TYPE request_type, int depth) {#define BUF_SIZE 512   xml_element* root = NULL;   if (node) {      char buf[BUF_SIZE];      XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(node);      XMLRPC_VECTOR_TYPE vtype = XMLRPC_GetVectorType(node);      xml_element* elem_val = xml_elem_new();      /* special case for when root element is not an array */      if (depth == 0 &&           !(type == xmlrpc_vector &&             vtype == xmlrpc_vector_array &&             request_type == xmlrpc_request_call) ) {         int bIsFault = (vtype == xmlrpc_vector_struct && XMLRPC_VectorGetValueWithID(node, ELEM_FAULTCODE));         xml_element* next_el = XMLRPC_to_xml_element_worker(NULL, node, request_type, depth + 1);         if (next_el) {            Q_PushTail(&elem_val->children, next_el);         }         elem_val->name = strdup(bIsFault ? ELEM_FAULT : ELEM_PARAMS);        }        else {         switch (type) {            case xmlrpc_empty: //  treat null value as empty string in xmlrpc.         case xmlrpc_string:            elem_val->name = strdup(ELEM_STRING);            simplestring_addn(&elem_val->text, XMLRPC_GetValueString(node), XMLRPC_GetValueStringLen(node));            break;         case xmlrpc_int:            elem_val->name = strdup(ELEM_INT);            snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueInt(node));            simplestring_add(&elem_val->text, buf);            break;         case xmlrpc_boolean:            elem_val->name = strdup(ELEM_BOOLEAN);            snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueBoolean(node));            simplestring_add(&elem_val->text, buf);            break;         case xmlrpc_double:            elem_val->name = strdup(ELEM_DOUBLE);            snprintf(buf, BUF_SIZE, "%f", XMLRPC_GetValueDouble(node));            simplestring_add(&elem_val->text, buf);            break;         case xmlrpc_datetime:            elem_val->name = strdup(ELEM_DATETIME);            simplestring_add(&elem_val->text, XMLRPC_GetValueDateTime_ISO8601(node));            break;         case xmlrpc_base64:            {               struct buffer_st buf;               elem_val->name = strdup(ELEM_BASE64);               base64_encode(&buf, XMLRPC_GetValueBase64(node), XMLRPC_GetValueStringLen(node));               simplestring_addn(&elem_val->text, buf.data, buf.offset );               buffer_delete(&buf);            }            break;         case xmlrpc_vector:            {               XMLRPC_VECTOR_TYPE my_type = XMLRPC_GetVectorType(node);               XMLRPC_VALUE xIter = XMLRPC_VectorRewind(node);               xml_element* root_vector_elem = elem_val;               switch (my_type) {               case xmlrpc_vector_array:                  {                      if(depth == 0) {                         elem_val->name = strdup(ELEM_PARAMS);                      }                      else {                         /* Hi my name is Dave and I like to make things as confusing                          * as possible, thus I will throw in this 'data' element                          * where it absolutely does not belong just so that people                          * cannot code arrays and structs in a similar and straight                          * forward manner. Have a good day.                          *                          * GRRRRRRRRR!                          */                         xml_element* data = xml_elem_new();                         data->name = strdup(ELEM_DATA);                             elem_val->name = strdup(ELEM_ARRAY);                         Q_PushTail(&elem_val->children, data);                         root_vector_elem = data;                      }                  }                  break;               case xmlrpc_vector_mixed:       /* not officially supported */               case xmlrpc_vector_struct:                  elem_val->name = strdup(ELEM_STRUCT);                  break;               default:                  break;               }               /* recurse through sub-elements */               while ( xIter ) {                  xml_element* next_el = XMLRPC_to_xml_element_worker(node, xIter, request_type, depth + 1);                  if (next_el) {//.........这里部分代码省略.........

static void monitor_update(iterator_t *it, pthread_mutex_t *recv_ready_mutex){	uint32_t total_sent = iterator_get_sent(it);	if (last_now > 0.0) {		double age = now() - zsend.start;		double delta = now() - last_now;		double remaining_secs = compute_remaining_time(age, total_sent);		double percent_complete = 100.*age/(age + remaining_secs);		// ask pcap for fresh values		pthread_mutex_lock(recv_ready_mutex);		recv_update_pcap_stats();		pthread_mutex_unlock(recv_ready_mutex);		// format times for display		char time_left[20];		if (age < 5) {			time_left[0] = '/0';		} else {			char buf[20];			time_string((int)remaining_secs, 1, buf, sizeof(buf));			snprintf(time_left, sizeof(time_left), " (%s left)", buf);		}		char time_past[20];		time_string((int)age, 0, time_past, sizeof(time_past));		char send_rate[20], send_avg[20],			 recv_rate[20], recv_avg[20],			 pcap_drop[20], pcap_drop_avg[20];		// recv stats		number_string((zrecv.success_unique - last_rcvd)/delta,						recv_rate, sizeof(recv_rate));		number_string((zrecv.success_unique/age), recv_avg, sizeof(recv_avg));		// dropped stats		number_string((zrecv.pcap_drop + zrecv.pcap_ifdrop - last_drop)/delta,						pcap_drop, sizeof(pcap_drop));		number_string(((zrecv.pcap_drop + zrecv.pcap_ifdrop)/age),						pcap_drop_avg, sizeof(pcap_drop_avg));		// Warn if we drop > 5% of our average receive rate		uint32_t drop_rate = (uint32_t)((zrecv.pcap_drop + zrecv.pcap_ifdrop - last_drop) / delta);		if (drop_rate > (uint32_t)((zrecv.success_unique - last_rcvd) / delta) / 20) {			log_warn("monitor", "Dropped %d packets in the last second, (%d total dropped (pcap: %d + iface: %d))",					 drop_rate, zrecv.pcap_drop + zrecv.pcap_ifdrop, zrecv.pcap_drop, zrecv.pcap_ifdrop);		}		// Warn if we fail to send > 1% of our average send rate		uint32_t fail_rate = (uint32_t)((zsend.sendto_failures - last_failures) / delta); // failures/sec		if (fail_rate > ((total_sent / age) / 100)) {			log_warn("monitor", "Failed to send %d packets/sec (%d total failures)",					 fail_rate, zsend.sendto_failures);		}		float hits;		if (!total_sent) {			hits = 0;		} else {			hits = zrecv.success_unique*100./total_sent;		}		if (!zsend.complete) {			// main display (during sending)			number_string((total_sent - last_sent)/delta,							send_rate, sizeof(send_rate));			number_string((total_sent/age), send_avg, sizeof(send_avg));			fprintf(stderr,					"%5s %0.0f%%%s; send: %u %sp/s (%sp/s avg); "					"recv: %u %sp/s (%sp/s avg); "					"drops: %sp/s (%sp/s avg); "					"hits: %0.2f%%/n",					time_past,					percent_complete,					time_left,					total_sent,					send_rate,					send_avg,					zrecv.success_unique,					recv_rate,					recv_avg,					pcap_drop,					pcap_drop_avg,					hits);		} else {		  	// alternate display (during cooldown)			number_string((total_sent/(zsend.finish - zsend.start)), send_avg, sizeof(send_avg));			fprintf(stderr,					"%5s %0.0f%%%s; send: %u done (%sp/s avg); "					"recv: %u %sp/s (%sp/s avg); "					"drops: %sp/s (%sp/s avg); "					"hits: %0.2f%%/n",					time_past,					percent_complete,					time_left,					total_sent,					send_avg,					zrecv.success_unique,					recv_rate,					recv_avg,					pcap_drop,					pcap_drop_avg,					hits);//.........这里部分代码省略.........

int Create_Semaphore (const char *name, int ival){//    struct Semaphore *pSem = 0, *pSemNew = NULL, sem;    struct Semaphore *pSem;    int id = 0;//Print("ARGS. name: %s, ival: %d/n", name, ival);    /*     * Obtiene el primer elemento de la lista y lo     * recorre hasta el final para ver que ID le asigna     * al semáforo solicitado (poco eficiente).     */    pSem = Get_Front_Of_Semaphore_List(&s_semList);//    Print("LISTA ARRANCA EN %p/n", pSem);    while (pSem != 0) {        KASSERT(pSem != Get_Next_In_Semaphore_List(pSem));        if (strcmp(pSem->name, name) == 0) {            pSem->nref++;#ifdef DEBUG            Print("Semaforo %s ya existe con id %d./n", name, pSem->id);#endif            Print("Semaforo %s ya existe con id %d./n", name, pSem->id);            return pSem->id;        }        pSem = Get_Next_In_Semaphore_List(pSem);        id++;    }    /* La cantidad máxima de semáforos está siendo utilizada. */    if (id >= MAX_SEM)        return -1;	pSem = Malloc(sizeof (struct Semaphore));//    Print("ANTES: ");//    Dump_All_Semaphore_List();//    sem.id = id;    pSem->id = id;    /* Define nombre del semáforo *///    snprintf(sem.name, sizeof(sem.name), "%s", name);    snprintf(pSem->name, NAMESIZE, "%s", name);    /* Define valor inicial del semáforo *///    sem.value = ival;    pSem->value = ival;    /* Referencia a 1 *///    sem.nref = 1;    pSem->nref = 1;/*	pSemNew = Malloc(sizeof (struct Semaphore));	pSemNew = &sem;*/    /* Agrega semáforo a la lista *///    Add_To_Back_Of_Semaphore_List(&s_semList, &sem);//    Add_To_Back_Of_Semaphore_List(&s_semList, pSemNew);    Add_To_Back_Of_Semaphore_List(&s_semList, pSem);/*    sem = Get_Front_Of_Semaphore_List(&s_semList);    while (sem != NULL) {        KASSERT(sem != Get_Next_In_Semaphore_List(sem));        Print("ESTE ID ya esta: %d/n", sem->id);        sem = Get_Next_In_Semaphore_List(sem);    }*/    Print("DESPUES: ");    Dump_All_Semaphore_List();#ifdef DEBUG    Print("ID: %d/n", id);#endif    return id;}

END_TESTSTART_TEST(importdb_can_parse_exported_database){	int i;	char buffer[512];	DATA filleddb;	FILE *exportfile;	initdb();	strcpy(data.interface, "something");	strcpy(data.nick, "nothing");	data.totalrx = 1;	data.totaltx = 2;	data.currx = 3;	data.curtx = 4;	data.totalrxk = 5;	data.totaltxk = 6;	data.btime = 7;	for (i=0; i<30; i++) {		data.day[i].date = i+1;		data.day[i].rx = data.day[i].tx = i*100;		data.day[i].rxk = data.day[i].txk = i;		data.day[i].used = 1;	}	for (i=0; i<10; i++) {		data.top10[i].date = i+1;		data.top10[i].rx = data.top10[i].tx = i*100;		data.top10[i].rxk = data.top10[i].txk = i;		data.top10[i].used = 1;	}	for (i=0; i<12; i++) {		data.month[i].month = i+1;		data.month[i].rx = data.month[i].tx = i*100;		data.month[i].rxk = data.month[i].txk = i;		data.month[i].used = 1;	}	for (i=0; i<24; i++) {		data.hour[i].date = i+1;		data.hour[i].rx = data.hour[i].tx = i*100;	}	memcpy(&filleddb, &data, sizeof(DATA));	ck_assert_int_eq(remove_directory(TESTDIR), 1);	ck_assert_int_eq(clean_testdbdir(), 1);	fflush(stdout);	snprintf(buffer, 512, "%s/dbexport", TESTDBDIR);	exportfile = fopen(buffer, "w");	dup2(fileno(exportfile), STDOUT_FILENO);	fclose(exportfile);	exportdb();	fflush(stdout);	memset(&data, '/0', sizeof(DATA));	ck_assert_int_gt(importdb(buffer), 0);	ck_assert_str_eq(data.interface, filleddb.interface);	ck_assert_str_eq(data.nick, filleddb.nick);	ck_assert_int_eq(data.version, filleddb.version);	ck_assert_int_eq(data.active, filleddb.active);	ck_assert_int_eq(data.totalrx, filleddb.totalrx);	ck_assert_int_eq(data.totaltx, filleddb.totaltx);	ck_assert_int_eq(data.currx, filleddb.currx);	ck_assert_int_eq(data.curtx, filleddb.curtx);	ck_assert_int_eq(data.totalrxk, filleddb.totalrxk);	ck_assert_int_eq(data.totaltxk, filleddb.totaltxk);	ck_assert_int_eq(data.btime, filleddb.btime);	ck_assert_int_eq(data.created, filleddb.created);	ck_assert_int_eq(data.lastupdated, filleddb.lastupdated);	for (i=0; i<30; i++) {		ck_assert_int_eq(data.day[i].date, filleddb.day[i].date);		ck_assert_int_eq(data.day[i].rx, filleddb.day[i].rx);		ck_assert_int_eq(data.day[i].tx, filleddb.day[i].tx);		ck_assert_int_eq(data.day[i].rxk, filleddb.day[i].rxk);		ck_assert_int_eq(data.day[i].txk, filleddb.day[i].txk);		ck_assert_int_eq(data.day[i].used, filleddb.day[i].used);	}	for (i=0; i<10; i++) {		ck_assert_int_eq(data.top10[i].date, filleddb.top10[i].date);		ck_assert_int_eq(data.top10[i].rx, filleddb.top10[i].rx);		ck_assert_int_eq(data.top10[i].tx, filleddb.top10[i].tx);		ck_assert_int_eq(data.top10[i].rxk, filleddb.top10[i].rxk);		ck_assert_int_eq(data.top10[i].txk, filleddb.top10[i].txk);		ck_assert_int_eq(data.top10[i].used, filleddb.top10[i].used);	}	for (i=0; i<12; i++) {		ck_assert_int_eq(data.month[i].month, filleddb.month[i].month);		ck_assert_int_eq(data.month[i].rx, filleddb.month[i].rx);		ck_assert_int_eq(data.month[i].tx, filleddb.month[i].tx);		ck_assert_int_eq(data.month[i].rxk, filleddb.month[i].rxk);		ck_assert_int_eq(data.month[i].txk, filleddb.month[i].txk);		ck_assert_int_eq(data.month[i].used, filleddb.month[i].used);//.........这里部分代码省略.........

int rpc_call(struct rpc_context *context,     const struct rpc_target *dest, const struct method_t *method,     rpc_callback client_cb, void *data) {    //TODO: check the protocol in dest->proto and do http    // request only if dest->proto == HTTP    int res = 1;    struct evhttp_connection *evcon = NULL;    struct evhttp_request *req = NULL;    char *json_method = NULL;    struct client_rpc_callback_with_data *ctx = NULL;    //TODO: can be make http_connection as part of peer_t?    evcon = evhttp_connection_base_new(        context->base, NULL, dest->host, dest->port);    if (!evcon) {        goto cleanup;    }    ctx = (struct client_rpc_callback_with_data *)malloc(        sizeof(struct client_rpc_callback_with_data));    if(!ctx) {        goto cleanup;    }    ctx->cb = client_cb;    ctx->data = data;    ctx->evcon = evcon;    req = evhttp_request_new(http_request_done, ctx);    if (!req) {        goto cleanup;    }    char uri[256];     snprintf(uri, sizeof(uri)-1, "http://%s:%d/rpc", dest->host, dest->port);        json_method  = serialize_method_call(method);    if(!json_method) {        goto cleanup;    }    struct evbuffer *output_buffer = evhttp_request_get_output_buffer(req);    evbuffer_add(output_buffer, json_method, strlen(json_method));    char content_length[20];    snprintf(content_length, sizeof(content_length)-1, "%d", (int)strlen(json_method));    struct evkeyvalq *output_headers = evhttp_request_get_output_headers(req);    evhttp_add_header(output_headers, "Host", dest->host);    evhttp_add_header(output_headers, "Connection", "close");    evhttp_add_header(output_headers, "Content-Length", content_length);    printf("Sending req %p with ctx = %p/n", req, ctx);    int r = evhttp_make_request(evcon, req, EVHTTP_REQ_POST, uri);    if(!r) {        res = 0;    }cleanup:    if(json_method)        free(json_method);    if(res && ctx)        free(ctx);    if(res && evcon)        evhttp_connection_free(evcon);    if(res && req)        evhttp_request_free(req);    return res;}

static voidoutvol(struct cfent **eptlist, int eptnum, int part, int nparts){	FILE	*fp;	char	*svpt, *path, temp[PATH_MAX];	int	i;	if (nparts > 1)		(void) fprintf(stderr, gettext(" -- part %2d:/n"), part);	if (part == 1) {		/* re-write pkgmap, but exclude local pathnames */		(void) snprintf(temp, sizeof (temp), "%s/pkgmap", pkgloc);		if ((fp = fopen(temp, "w")) == NULL) {			progerr(gettext(ERR_TEMP), errno);			quit(99);		}		(void) fprintf(fp, ": %d %ld/n", nparts, limit);		for (i = 0; eptlist[i]; i++) {			svpt = eptlist[i]->ainfo.local;			if (!strchr("sl", eptlist[i]->ftype))				eptlist[i]->ainfo.local = NULL;			if (ppkgmap(eptlist[i], fp)) {				progerr(gettext(ERR_TEMP), errno);				quit(99);			}			eptlist[i]->ainfo.local = svpt;		}		(void) fclose(fp);		(void) fprintf(stderr, "%s/n", temp);	}	(void) snprintf(temp, sizeof (temp), "%s/pkginfo", pkgloc);	if (copyf(svept->ainfo.local, temp, svept->cinfo.modtime))		quit(1);	(void) fprintf(stderr, "%s/n", temp);	for (i = 0; i < eptnum; i++) {		if (eptlist[i]->volno != part)			continue;		if (strchr("dxslcbp", eptlist[i]->ftype))			continue;		if (eptlist[i]->ftype == 'i') {			if (eptlist[i] == svept)				continue; /* don't copy pkginfo file */			(void) snprintf(temp, sizeof (temp),				"%s/install/%s", pkgloc,				eptlist[i]->path);			path = temp;		} else			path = srcpath(pkgloc, eptlist[i]->path, part, nparts);		if (sflag) {			if (slinkf(eptlist[i]->ainfo.local, path))				quit(1);		} else if (copyf(eptlist[i]->ainfo.local, path,				eptlist[i]->cinfo.modtime)) {			quit(1);		}		/*		 * If the package file attributes can be sync'd up with		 * the pkgmap, we fix the attributes here.		 */		if (*(eptlist[i]->ainfo.owner) != '$' &&		    *(eptlist[i]->ainfo.group) != '$' && getuid() == 0) {			/* Clear dangerous bits. */			eptlist[i]->ainfo.mode=			    (eptlist[i]->ainfo.mode & S_IAMB);			/*			 * Make sure it can be read by the world and written			 * by root.			 */			eptlist[i]->ainfo.mode |= 0644;			if (!strchr("in", eptlist[i]->ftype)) {				/* Set the safe attributes. */				averify(1, &(eptlist[i]->ftype),				    path, &(eptlist[i]->ainfo));			}		}		(void) fprintf(stderr, "%s/n", path);	}}

static intnetfilter_inject_linux(pcap_t *handle, const void *buf, size_t size){	snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on netfilter devices");	return (-1);}                           

struct iprange *set_range (char *word, char *value, struct iprange *in){    char *c, *d = NULL, *e = NULL;    struct iprange *ipr, *p;    struct hostent *hp;	int count = 0;    c = strchr (value, '-');    if (c)    {        d = c + 1;        *c = 0;        while ((c >= value) && (*c < 33))            *(c--) = 0;        while (*d && (*d < 33))            d++;    }    if (!strlen (value) || (c && !strlen (d)))    {        snprintf (filerr, sizeof (filerr),                  "format is '%s <host or ip> - <host or ip>'/n", word);        return NULL;    }    ipr = (struct iprange *) malloc (sizeof (struct iprange));    ipr->next = NULL;    hp = gethostbyname (value);    if (!hp)    {        snprintf (filerr, sizeof (filerr), "Unknown host %s/n", value);        free (ipr);        return NULL;    }    bcopy (hp->h_addr, &ipr->start, sizeof (unsigned int));    if (c)    {		char ip_hi[16];		e = d;		while(*e != '/0') {			if (*e++ == '.')				count++;		}		if (count < 3) {			strcpy(ip_hi, value);			for (e = ip_hi + sizeof(ip_hi); e >= ip_hi; e--) {				if (*e == '.') count--;				if (count < 0) {					e++;					break;				}			}			/* Copy the last field + null terminator */			if (ip_hi + sizeof(ip_hi)-e > strlen(d)) {				strcpy(e, d);				d = ip_hi;			}		}        hp = gethostbyname (d);        if (!hp)        {            snprintf (filerr, sizeof (filerr), "Unknown host %s/n", d);            free (ipr);            return NULL;        }        bcopy (hp->h_addr, &ipr->end, sizeof (unsigned int));    }    else        ipr->end = ipr->start;    if (ntohl (ipr->start) > ntohl (ipr->end))    {        snprintf (filerr, sizeof (filerr), "start is greater than end!/n");        free (ipr);        return NULL;    }    if (word[0] == 'n')        ipr->sense = SENSE_DENY;    else        ipr->sense = SENSE_ALLOW;    p = in;    if (p)    {        while (p->next)            p = p->next;        p->next = ipr;        return in;    }    else        return ipr;}

static intnflog_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user){	const unsigned char *buf;	int count = 0;	int len;	/* ignore interrupt system call error */	do {		len = recv(handle->fd, handle->buffer, handle->bufsize, 0);		if (handle->break_loop) {			handle->break_loop = 0;			return -2;		}	} while ((len == -1) && (errno == EINTR));	if (len < 0) {		snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't receive packet %d:%s", errno, pcap_strerror(errno));		return -1;	}	buf = handle->buffer;	while (len >= NLMSG_SPACE(0)) {		const struct nlmsghdr *nlh = (const struct nlmsghdr *) buf;		u_int32_t msg_len;		if (nlh->nlmsg_len < sizeof(struct nlmsghdr) || len < nlh->nlmsg_len) {			snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Message truncated: (got: %d) (nlmsg_len: %u)", len, nlh->nlmsg_len);			return -1;		}		if (NFNL_SUBSYS_ID(nlh->nlmsg_type) == NFNL_SUBSYS_ULOG && 			NFNL_MSG_TYPE(nlh->nlmsg_type) == NFULNL_MSG_PACKET) 		{			const unsigned char *payload = NULL;			struct pcap_pkthdr pkth;			if (handle->linktype != DLT_NFLOG) {				const struct nfattr *payload_attr = NULL;				if (nlh->nlmsg_len < HDR_LENGTH) {					snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Malformed message: (nlmsg_len: %u)", nlh->nlmsg_len);					return -1;				}				if (nlh->nlmsg_len > HDR_LENGTH) {					struct nfattr *attr = NFM_NFA(NLMSG_DATA(nlh));					int attr_len = nlh->nlmsg_len - NLMSG_ALIGN(HDR_LENGTH);					while (NFA_OK(attr, attr_len)) {						switch (NFA_TYPE(attr)) {							case NFULA_PAYLOAD:								payload_attr = attr;								break;						}						attr = NFA_NEXT(attr, attr_len);					}				}				if (payload_attr) {					payload = NFA_DATA(payload_attr);					pkth.len = pkth.caplen = NFA_PAYLOAD(payload_attr);				}			} else {				payload = NLMSG_DATA(nlh);				pkth.caplen = pkth.len = nlh->nlmsg_len-NLMSG_ALIGN(sizeof(struct nlmsghdr));			}			if (payload) {				/* pkth.caplen = min (payload_len, handle->snapshot); */				gettimeofday(&pkth.ts, NULL);				if (handle->fcode.bf_insns == NULL ||						bpf_filter(handle->fcode.bf_insns, payload, pkth.len, pkth.caplen)) 				{					handle->md.packets_read++;					callback(user, &pkth, payload);					count++;				}			}		}		msg_len = NLMSG_ALIGN(nlh->nlmsg_len);		if (msg_len > len)			msg_len = len;		len -= msg_len;		buf += msg_len;	}	return count;}

void get_ext_md_post_fix(int md_id, char buf[], char buf_ex[]){	// name format: modem_X_YYY_Z_Ex.img	int		X, Ex;	char		YYY[8];#if defined(DFO_FEATURE_EN)	unsigned int	feature_val = 0;#endif  if (md_id < MD_SYS5) {    printk("[EEMCS]wrong MD ID to get postfix %d/n", md_id);    return;  }	// X	X = md_id + 1;#if defined(DFO_FEATURE_EN)	// DFO start -------------------	// YYY	YYY[0] = '/0';	switch(md_id) {  	case MD_SYS5:  		feature_val = ext_md_support[MD_SYS5-MD_EXT1];  		break;  	default:      printk("[EEMCS]request MD ID %d not supported/n", md_id);  		break;	}	switch(feature_val) {  	case modem_lwg:  		snprintf(YYY, 8, "_lwg_n");  		break;  	case modem_ltg:  		snprintf(YYY, 8, "_ltg_n");  		break;  	default:  		printk("[EEMCS]request MD type %d not supported/n", feature_val);  		break;	}	// DFO end ---------------------#else	// Static start -------------------	// YYY	snprintf(YYY, 8, "_lwg_n");	// Static end ---------------------#endif	// [_Ex] Get chip version#if 0	if(get_chip_version() == CHIP_SW_VER_01)		Ex = 1;	else if(get_chip_version() == CHIP_SW_VER_02)		Ex = 2;#else	Ex = 1;#endif	// Gen post fix	if(buf) {		snprintf(buf, 12, "%d%s", X, YYY);    printk("[EEMCS]MD%d image postfix=%s/n", md_id, buf);	}	if(buf_ex) {		snprintf(buf_ex, 12, "%d%s_E%d", X, YYY, Ex);    printk("[EEMCS]MD%d image postfix=%s/n", md_id, buf_ex);	}}

//.........这里部分代码省略.........	if (width != NULL)		card('W', width);	/*	 * XXX	 * Our use of `Z' here is incompatible with LPRng's	 * use.  We assume that the only use of our existing	 * `Z' card is as shown for `p' format (pr) files.	 */	if (format == 'p') {		char *s;		if (locale)			card('Z', locale);		else if ((s = setlocale(LC_TIME, "")) != NULL)			card('Z', s);	}	/*	 * Read the files and spool them.	 */	if (argc == 0)		copy(pp, 0, " ");	else while (argc--) {		if (argv[0][0] == '-' && argv[0][1] == '/0') {			/* use stdin */			copy(pp, 0, " ");			argv++;			continue;		}		if ((f = test(arg = *argv++)) < 0)			continue;	/* file unreasonable */		if (sflag && (cp = linked(arg)) != NULL) {			(void)snprintf(buf, sizeof(buf), "%ju %ju",			    (uintmax_t)statb.st_dev, (uintmax_t)statb.st_ino);			card('S', buf);			if (format == 'p')				card('T', title ? title : arg);			for (i = 0; i < ncopies; i++)				card(format, &dfname[inchar-2]);			card('U', &dfname[inchar-2]);			if (f)				card('U', cp);			card('N', arg);			dfname[inchar]++;			nact++;			continue;		}		if (sflag)			printf("%s: %s: not linked, copying instead/n",			    progname, arg);		if (f) {			/*			 * The user wants the file removed after it is copied			 * to the spool area, so see if the file can be moved			 * instead of copy/unlink'ed.  This is much faster and			 * uses less spool space than copying the file.  This			 * can be very significant when running services like			 * samba, pcnfs, CAP, et al.			 */			PRIV_START			didlink = 0;			/*			 * There are several things to check to avoid any			 * security issues.  Some of these are redundant

static int dm5_dive(void *param, int columns, char **data, char **column){	UNUSED(columns);	UNUSED(column);	int i;	int tempformat = 0;	int interval, retval = 0, block_size;	struct parser_state *state = (struct parser_state *)param;	sqlite3 *handle = state->sql_handle;	unsigned const char *sampleBlob;	char *err = NULL;	char get_events_template[] = "select * from Mark where DiveId = %d";	char get_tags_template[] = "select Text from DiveTag where DiveId = %d";	char get_cylinders_template[] = "select * from DiveMixture where DiveId = %d";	char get_gaschange_template[] = "select GasChangeTime,Oxygen,Helium from DiveGasChange join DiveMixture on DiveGasChange.DiveMixtureId=DiveMixture.DiveMixtureId where DiveId = %d";	char get_events[512];	dive_start(state);	state->cur_dive->number = atoi(data[0]);	state->cur_dive->when = (time_t)(atol(data[1]));	if (data[2])		utf8_string(data[2], &state->cur_dive->notes);	if (data[3])		state->cur_dive->duration.seconds = atoi(data[3]);	if (data[15])		state->cur_dive->dc.duration.seconds = atoi(data[15]);	/*	 * TODO: the deviceid hash should be calculated here.	 */	settings_start(state);	dc_settings_start(state);	if (data[4]) {		utf8_string(data[4], &state->cur_settings.dc.serial_nr);		state->cur_settings.dc.deviceid = atoi(data[4]);	}	if (data[5])		utf8_string(data[5], &state->cur_settings.dc.model);	dc_settings_end(state);	settings_end(state);	if (data[6])		state->cur_dive->dc.maxdepth.mm = lrint(strtod_flags(data[6], NULL, 0) * 1000);	if (data[8])		state->cur_dive->dc.airtemp.mkelvin = C_to_mkelvin(atoi(data[8]));	if (data[9])		state->cur_dive->dc.watertemp.mkelvin = C_to_mkelvin(atoi(data[9]));	if (data[4]) {		state->cur_dive->dc.deviceid = atoi(data[4]);	}	if (data[5])		utf8_string(data[5], &state->cur_dive->dc.model);	snprintf(get_events, sizeof(get_events) - 1, get_cylinders_template, state->cur_dive->number);	retval = sqlite3_exec(handle, get_events, &dm5_cylinders, state, &err);	if (retval != SQLITE_OK) {		fprintf(stderr, "%s", "Database query dm5_cylinders failed./n");		return 1;	}	if (data[14])		state->cur_dive->dc.surface_pressure.mbar = (atoi(data[14]) / 100);	interval = data[16] ? atoi(data[16]) : 0;	/*	 * sampleBlob[0]	version number, indicates the size of one sample	 *	 * Following ones describe single sample, bugs in interpretation of the binary blob are likely:	 *	 * sampleBlob[3]	depth	 * sampleBlob[7-9]	pressure	 * sampleBlob[11]	temperature - either full Celsius or float, might be different field for some version of DM	 */	sampleBlob = (unsigned const char *)data[24];	if (sampleBlob) {		switch (sampleBlob[0]) {			case 1:				// Log is converted from DM4 to DM5				block_size = 16;				break;			case 2:				block_size = 19;				break;			case 3:				block_size = 23;				break;			case 4:				// Temperature is stored in float				tempformat = 1;				block_size = 26;				break;			case 5:				// Temperature is stored in float//.........这里部分代码省略.........

static int recv_fd(int c){    int fd;    uint8_t msgbuf[CMSG_SPACE(sizeof(fd))];    struct msghdr msg = {        .msg_control = msgbuf,        .msg_controllen = sizeof(msgbuf),    };    struct cmsghdr *cmsg;    struct iovec iov;    uint8_t req[1];    ssize_t len;    cmsg = CMSG_FIRSTHDR(&msg);    cmsg->cmsg_level = SOL_SOCKET;    cmsg->cmsg_type = SCM_RIGHTS;    cmsg->cmsg_len = CMSG_LEN(sizeof(fd));    msg.msg_controllen = cmsg->cmsg_len;    iov.iov_base = req;    iov.iov_len = sizeof(req);    msg.msg_iov = &iov;    msg.msg_iovlen = 1;    len = recvmsg(c, &msg, 0);    if (len > 0) {        memcpy(&fd, CMSG_DATA(cmsg), sizeof(fd));        return fd;    }    return len;}static int net_bridge_run_helper(const char *helper, const char *bridge,                                 Error **errp){    sigset_t oldmask, mask;    int pid, status;    char *args[5];    char **parg;    int sv[2];    sigemptyset(&mask);    sigaddset(&mask, SIGCHLD);    sigprocmask(SIG_BLOCK, &mask, &oldmask);    if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) == -1) {        error_setg_errno(errp, errno, "socketpair() failed");        return -1;    }    /* try to launch bridge helper */    pid = fork();    if (pid < 0) {        error_setg_errno(errp, errno, "Can't fork bridge helper");        return -1;    }    if (pid == 0) {        int open_max = sysconf(_SC_OPEN_MAX), i;        char fd_buf[6+10];        char br_buf[6+IFNAMSIZ] = {0};        char helper_cmd[PATH_MAX + sizeof(fd_buf) + sizeof(br_buf) + 15];        for (i = 3; i < open_max; i++) {            if (i != sv[1]) {                close(i);            }        }        snprintf(fd_buf, sizeof(fd_buf), "%s%d", "--fd=", sv[1]);        if (strrchr(helper, ' ') || strrchr(helper, '/t')) {            /* assume helper is a command */            if (strstr(helper, "--br=") == NULL) {                snprintf(br_buf, sizeof(br_buf), "%s%s", "--br=", bridge);            }            snprintf(helper_cmd, sizeof(helper_cmd), "%s %s %s %s",                     helper, "--use-vnet", fd_buf, br_buf);            parg = args;            *parg++ = (char *)"sh";            *parg++ = (char *)"-c";            *parg++ = helper_cmd;            *parg++ = NULL;            execv("/bin/sh", args);        } else {            /* assume helper is just the executable path name */            snprintf(br_buf, sizeof(br_buf), "%s%s", "--br=", bridge);            parg = args;            *parg++ = (char *)helper;            *parg++ = (char *)"--use-vnet";            *parg++ = fd_buf;            *parg++ = br_buf;            *parg++ = NULL;//.........这里部分代码省略.........

void CGPS9_00HandleEvents(t_CgpsEventInformation* pp_EventInfo){    uint8_t   vl_CharactersWritten = 0;    uint8_t   vl_CheckSum          = 0;    char vl_NmeaBuffer[K_CGPS_MAX_NMEA_SIZE];    /*++  For adding newline at the end of PSTE messages */    char vl_PsteBuffer[K_CGPS_MAX_NMEA_SIZE];    /*--  For adding newline at the end of PSTE messages *//* + LMSQC19754 */    /*The transview tool expects the PSTE messages to have a timestamp that is in resolution of 4ms*/    uint32_t  vl_timer             = (uint32_t)GN_GPS_Get_OS_Time_ms() / 4;/*    uint32_t  vl_timer             = GN_GPS_Get_OS_Time_ms(); *//* - LMSQC19754 */    vl_CharactersWritten = snprintf(vl_NmeaBuffer, K_CGPS_MAX_NMEA_SIZE, "$PSTE,");    switch( pp_EventInfo->v_EventType )    {        case K_CGPS_RESPONSE_RETURNED:            vl_CharactersWritten += MC_CGPS_ADD_PSTE_TYPE(vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten, 4);  /* Pste type */            vl_CharactersWritten += MC_CGPS_ADD_OS_TIME  (vl_NmeaBuffer+vl_CharactersWritten, vl_timer, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);                /*OS time*/            vl_CharactersWritten += MC_CGPS_ADD_SEPERATOR(vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);                          /* , */            vl_CharactersWritten += MC_CGPS_ADD_LATLON(vl_NmeaBuffer+vl_CharactersWritten, pp_EventInfo->v_Latitude, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);/*Latitude*/            vl_CharactersWritten += MC_CGPS_ADD_SEPERATOR(vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);                          /* , */            vl_CharactersWritten += MC_CGPS_ADD_LATLON  (vl_NmeaBuffer+vl_CharactersWritten, pp_EventInfo->v_Longitude, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);/*Longitude*/            vl_CharactersWritten += MC_CGPS_ADD_SEPERATOR(vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);                          /* , */            vl_CharactersWritten += MC_CGPS_ADD_ALT  (vl_NmeaBuffer+vl_CharactersWritten, pp_EventInfo->v_Altitude, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);/*Altitude*/            vl_CharactersWritten += MC_CGPS_ADD_EOM      (vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);                          /* * */        break;        case K_CGPS_POSITIONING_SESSION_START:            vl_CharactersWritten += MC_CGPS_ADD_PSTE_TYPE(vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten, 1);            vl_CharactersWritten += MC_CGPS_ADD_OS_TIME  (vl_NmeaBuffer+vl_CharactersWritten, vl_timer, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);            vl_CharactersWritten += MC_CGPS_ADD_EOM      (vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);        break;        case K_CGPS_POSITIONING_SESSION_END:            vl_CharactersWritten += MC_CGPS_ADD_PSTE_TYPE(vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten, 2);            vl_CharactersWritten += MC_CGPS_ADD_OS_TIME  (vl_NmeaBuffer+vl_CharactersWritten, vl_timer, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);            vl_CharactersWritten += MC_CGPS_ADD_EOM      (vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);        break;/* + LMSQC19754 */        case K_CGPS_ABORT_SESSION:            vl_CharactersWritten += MC_CGPS_ADD_PSTE_TYPE(vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten, 3);            vl_CharactersWritten += MC_CGPS_ADD_OS_TIME  (vl_NmeaBuffer+vl_CharactersWritten, vl_timer, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);            vl_CharactersWritten += MC_CGPS_ADD_EOM      (vl_NmeaBuffer+vl_CharactersWritten, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);        break;/* - LMSQC19754 */        default:        break;    }    vl_CheckSum = CGPS9_01GenerateCheckSum(vl_NmeaBuffer, strlen((const char*)vl_NmeaBuffer));    vl_CharactersWritten += MC_CGPS_ADD_CS (vl_NmeaBuffer+vl_CharactersWritten, vl_CheckSum, K_CGPS_MAX_NMEA_SIZE-vl_CharactersWritten);    MC_CGPS_TRACE(("%s", vl_NmeaBuffer));    sprintf(vl_PsteBuffer,"%s/r/n",vl_NmeaBuffer);/*--  For adding newline at the end of PSTE messages */    if( vg_CgpsTestall.p_Callback != NULL  )    {        t_cgps_NavData vl_NavDataToSend;        vl_NavDataToSend.v_Type    = K_CGPS_NMEA;        vl_NavDataToSend.v_Length  = vl_CharactersWritten;        vl_NavDataToSend.p_NavData = vl_NmeaBuffer;        /*++  For adding newline at the end of PSTE messages */        sprintf(vl_PsteBuffer,"%s/r/n",vl_NavDataToSend.p_NavData);        vl_NavDataToSend.v_Length  += 2;        vl_NavDataToSend.p_NavData = vl_PsteBuffer;        MC_CGPS_TRACE(("In CGPS9_00HandleEvents calling p_Callback"));        (vg_CgpsTestall.p_Callback)( vl_NavDataToSend );    /*--  For adding newline at the end of PSTE messages */    }    /* + DUR 19 Jan 2011 NMEA Logging */       CGPS4_11SendAcknowledge(vl_PsteBuffer);    /* - DUR 19 Jan 2011 NMEA Logging */}

static void net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,                             const char *model, const char *name,                             const char *ifname, const char *script,                             const char *downscript, const char *vhostfdname,                             int vnet_hdr, int fd, Error **errp){    Error *err = NULL;    TAPState *s = net_tap_fd_init(peer, model, name, fd, vnet_hdr);    int vhostfd;    tap_set_sndbuf(s->fd, tap, &err);    if (err) {        error_propagate(errp, err);        return;    }    if (tap->has_fd || tap->has_fds) {        snprintf(s->nc.info_str, sizeof(s->nc.info_str), "fd=%d", fd);    } else if (tap->has_helper) {        snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s",                 tap->helper);    } else {        snprintf(s->nc.info_str, sizeof(s->nc.info_str),                 "ifname=%s,script=%s,downscript=%s", ifname, script,                 downscript);        if (strcmp(downscript, "no") != 0) {            snprintf(s->down_script, sizeof(s->down_script), "%s", downscript);            snprintf(s->down_script_arg, sizeof(s->down_script_arg),                     "%s", ifname);        }    }    if (tap->has_vhost ? tap->vhost :        vhostfdname || (tap->has_vhostforce && tap->vhostforce)) {        VhostNetOptions options;        options.backend_type = VHOST_BACKEND_TYPE_KERNEL;        options.net_backend = &s->nc;        if (tap->has_poll_us) {            options.busyloop_timeout = tap->poll_us;        } else {            options.busyloop_timeout = 0;        }        if (vhostfdname) {            vhostfd = monitor_fd_param(cur_mon, vhostfdname, &err);            if (vhostfd == -1) {                error_propagate(errp, err);                return;            }        } else {            vhostfd = open("/dev/vhost-net", O_RDWR);            if (vhostfd < 0) {                error_setg_errno(errp, errno,                                 "tap: open vhost char device failed");                return;            }        }        options.opaque = (void *)(uintptr_t)vhostfd;        s->vhost_net = vhost_net_init(&options);        if (!s->vhost_net) {            error_setg(errp,                       "vhost-net requested but could not be initialized");            return;        }    } else if (vhostfdname) {        error_setg(errp, "vhostfd(s)= is not valid without vhost");    }}

int vzctl2_env_unreg(struct vzctl_env_handle *h, int flags){	char buf[STR_SIZE];	char host[STR_SIZE];	int ret;	const char *ve_root;	const char *ve_private = h->env_param->fs->ve_private;	/* preserve compatibility	 * VZ_REG_SKIP_HA_CLUSTER is alias for VZ_REG_SKIP_CLUSTER	 */	if (flags & VZ_REG_SKIP_HA_CLUSTER)		flags |= VZ_REG_SKIP_CLUSTER;	if (is_env_run(h))		return vzctl_err(VZCTL_E_ENV_RUN, 0,			"Container is running, Stop Container before proceeding.");	if (access(ve_private, F_OK) && errno == ENOENT) {		ret = unregister_env_conf(h);		if (ret)			return ret;		goto out;	}	if (vzctl2_env_layout_version(ve_private) < VZCTL_LAYOUT_4)		return 0;	ret = vzctl_check_owner_quiet(ve_private, buf, sizeof(buf), host, sizeof(host));	if (ret == VZCTL_E_ENV_MANAGE_DISABLED) {		logger(0, 0, "Owner check failed on the server '%s':"				" Container (%s) is registered for '%s'",				buf, ve_private, host);		ret = unregister_env_conf(h);		if (ret)			return ret;		goto out;	} else if (ret)		return ret;	ve_root = h->env_param->fs->ve_root;	if (ve_root != NULL && vzctl2_env_is_mounted(h) == 1) {		if (vzctl2_env_umount(h, 0))			return vzctl_err(VZCTL_E_FS_MOUNTED, 0,				"Container is mounted, Unmount Container "				"before proceeding.");	}	if (!(flags & VZ_UNREG_PRESERVE)) {		/* Remove VEID from /ve_private/ve.conf */		vzctl2_env_set_param(h, "VEID", NULL);		if (vzctl2_env_save(h))			return VZCTL_E_UNREGISTER;		/* Remove VE_PRIVATE/.owner */		snprintf(buf, sizeof(buf), "%s/" VZCTL_VE_OWNER, ve_private);		unlink(buf);	}	/* cleanup name */	if (h->env_param->name->name != NULL) {		char name_path[PATH_MAX];		char veconf[PATH_MAX];		snprintf(veconf, sizeof(veconf), "%s/" VZCTL_VE_CONF, ve_private);		snprintf(name_path, sizeof(name_path), ENV_NAME_DIR "%s",				h->env_param->name->name);		if (is_same_file(name_path, veconf))			unlink(name_path);	}	/* Remove /etc/vz/conf/VEID.conf */	unregister_env_conf(h);	if (!(flags & VZ_REG_SKIP_CLUSTER) &&			is_shared_fs(ve_private) &&			shaman_del_resource(EID(h)))		logger(0, 0,"Warning: Failed to unregister the Container on HA cluster");out:	vzctl2_destroy_net_stat(h, 0);	vzctl2_send_state_evt(EID(h), VZCTL_ENV_UNREGISTERED);	logger(0, 0, "Container unregistered succesfully");	return 0;}

socket_thtsp_tcp_connect_addr(struct addrinfo* addr, char *errbuf, size_t errbufsize,	    int timeout){  socket_t fd;  int r, err, val;  socklen_t errlen = sizeof(int);  fd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);  if(fd == -1) {    snprintf(errbuf, errbufsize, "Unable to create socket: %s",	     strerror(WSAGetLastError()));    return -1;  }  /**   * Switch to nonblocking   */  val = 1;  ioctlsocket(fd, FIONBIO, &val);  r = connect(fd, addr->ai_addr, addr->ai_addrlen);  if(r == -1) {    if(WSAGetLastError() == EINPROGRESS ||       WSAGetLastError() == EAGAIN) {      fd_set fd_write, fd_except;      struct timeval tv;      tv.tv_sec  =         timeout / 1000;      tv.tv_usec = 1000 * (timeout % 1000);      FD_ZERO(&fd_write);      FD_ZERO(&fd_except);      FD_SET(fd, &fd_write);      FD_SET(fd, &fd_except);      r = select((int)fd+1, NULL, &fd_write, &fd_except, &tv);      if(r == 0) {        /* Timeout */        snprintf(errbuf, errbufsize, "Connection attempt timed out");        closesocket(fd);        return -1;      }      if(r == -1) {        snprintf(errbuf, errbufsize, "select() error: %s", strerror(WSAGetLastError()));        closesocket(fd);        return -1;      }      getsockopt(fd, SOL_SOCKET, SO_ERROR, (void *)&err, &errlen);    } else {      err = WSAGetLastError();    }  } else {    err = 0;  }  if(err != 0) {    snprintf(errbuf, errbufsize, "%s", strerror(err));    closesocket(fd);    return -1;  }  val = 0;  ioctlsocket(fd, FIONBIO, &val);  val = 1;  setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (const char*)&val, sizeof(val));  return fd;}

int vzctl2_get_free_envid(unsigned *neweid, const char *dst,		const char *unused){	int i;	struct vzctl_conf_simple conf;	char file[STR_SIZE];	char lckfile[STR_SIZE];	char dstlck[PATH_MAX];	struct stat st;	int check_ve_private = 0;	int check_ve_root = 0;	int check_dst = 0;	int fail_cnt = 0;	int fd;	ctid_t ctid = {};	vzctl_parse_conf_simple(ctid, GLOBAL_CFG, &conf);	if (conf.ve_private_orig != NULL && strstr(conf.ve_private_orig, "$VEID"))		check_ve_private = 1;	if (conf.ve_root_orig != NULL && strstr(conf.ve_root_orig, "$VEID"))		check_ve_root = 1;	if (dst != NULL && strstr(dst, "$VEID")) {		snprintf(dstlck, sizeof(dstlck), "%s.lck", dst);		check_dst = 1;	}	*neweid = 0;	for (i = START_ID; i < INT_MAX/2 && fail_cnt < GET_FREE_ENVID_FAIL_MAX; i++) {		ctid_t ctid = {i, };		/* Check for VEID.conf */		vzctl2_get_env_conf_path(ctid, file, sizeof(file));		if (lstat(file, &st)) {			if (errno != ENOENT) {				logger(-1, errno, "Failed to stat %s", file);				fail_cnt++;				continue;			}		} else			continue;		/* lock envid */		snprintf(lckfile, sizeof(lckfile), "%s.lck", file);		fd = open(lckfile, O_CREAT|O_EXCL, 0644);		if (fd == -1) {			if (errno != EEXIST) {				fail_cnt++;				logger(-1, errno, "Failed to create %s", lckfile);			}			continue;		}		close(fd);		/* check if PATH(s) exist */		if ((check_ve_private && !is_dst_free(conf.ve_private_orig, ctid, &fail_cnt)) ||		    (check_ve_root && !is_dst_free(conf.ve_root_orig, ctid, &fail_cnt)) ||		    (check_dst &&			(!is_dst_free(dst, ctid, &fail_cnt) || !is_dst_free(dstlck, ctid, &fail_cnt))))		{			/* unlock envid */			unlink(lckfile);			continue;		}		*neweid = i;		break;	}	vzctl_free_conf_simple(&conf);	if (*neweid == 0)		return vzctl_err(-1, 0,  "Failed to get unused Countainer id");	return 0;}

//.........这里部分代码省略.........	}	param[0] = '/0';	while (value = fpkgparam(fp, param)) {		if (getenv(param) == NULL)			putparam(param, value);		free((void *)value);		param[0] = '/0';	}	(void) fclose(fp);	/* add command line variables */	while (*cmdparam && (value = strchr(*cmdparam, '=')) != NULL) {		*value = NULL;	/* terminate the parameter */		value++;	/* value is now the value (not '=') */		putparam(*cmdparam++, value);  /* store it in environ */	}	/* make sure parameters are valid */	(void) time(&clock);	if (pt = getenv("PKG")) {		if (pkgnmchk(pt, NULL, 0) || strchr(pt, '.')) {			progerr(gettext(ERR_PKGABRV), pt);			quit(1);		}		if (pkginst == NULL)			pkginst = pt;	} else {		progerr(gettext(ERR_NOPARAM), "PKG", svept->path);		quit(1);	}	/*	 * verify consistency between PKG parameter and pkginst	 */	(void) snprintf(param, sizeof (param), "%s.*", pt);	if (pkgnmchk(pkginst, param, 0)) {		progerr(gettext(ERR_PKGMTCH), pt, pkginst);		quit(1);	}	/*	 * *********************************************************************	 * this feature is removed starting with Solaris 10 - there is no built	 * in list of packages that should be run "the old way"	 * *********************************************************************	 */#ifdef	ALLOW_EXCEPTION_PKG_LIST	/* Until 2.9, set it from the execption list */	if (exception_pkg(pkginst, LINK))		set_nonABI_symlinks();#endif	if ((pkgname = getenv("NAME")) == NULL) {		progerr(gettext(ERR_NOPARAM), "NAME", svept->path);		quit(1);	}	if (ckparam("NAME", pkgname))		quit(1);	if ((pkgvers = getenv("VERSION")) == NULL) {		/* XXX - I18n */		/* LINTED do not use cftime(); use strftime instead */		(void) cftime(buf, "/045m//045d//045Y", &clock);		(void) snprintf(temp, sizeof (temp),			gettext("Dev Release %s"), buf);		putparam("VERSION", temp);		pkgvers = getenv("VERSION");

//.........这里部分代码省略.........	{					pAd->CommonCfg.wapi_usk_rekey_threshold = simple_strtol(tmpbuf, 0, 10); 		DBGPRINT(RT_DEBUG_TRACE, ("WapiUskRekeyThreshold=%d/n", pAd->CommonCfg.wapi_usk_rekey_threshold));			   	}	// WapiMskRekeyMethod	if (RTMPGetKeyParameter("WapiMskRekeyMethod", tmpbuf, 32, buffer, TRUE))	{				if ((strcmp(tmpbuf, "TIME") == 0) || (strcmp(tmpbuf, "time") == 0))			pAd->CommonCfg.wapi_msk_rekey_method = REKEY_METHOD_TIME;		else if ((strcmp(tmpbuf, "PKT") == 0) || (strcmp(tmpbuf, "pkt") == 0))			pAd->CommonCfg.wapi_msk_rekey_method = REKEY_METHOD_PKT;		else			pAd->CommonCfg.wapi_msk_rekey_method = REKEY_METHOD_DISABLE;		DBGPRINT(RT_DEBUG_TRACE, ("WapiMskRekeyMethod=%d/n", pAd->CommonCfg.wapi_msk_rekey_method));			   	}	// WapiMskRekeyThreshold	if (RTMPGetKeyParameter("WapiMskRekeyThreshold", tmpbuf, 32, buffer, TRUE))	{		pAd->CommonCfg.wapi_msk_rekey_threshold = simple_strtol(tmpbuf, 0, 10); 		DBGPRINT(RT_DEBUG_TRACE, ("WapiMskRekeyThreshold=%d/n", pAd->CommonCfg.wapi_msk_rekey_threshold));			   	}	#ifdef CONFIG_AP_SUPPORT	IF_DEV_CONFIG_OPMODE_ON_AP(pAd)	{								STRING tok_str[16];		// WapiPskX				for (apidx = 0; apidx < pAd->ApCfg.BssidNum; apidx++)		{			snprintf(tok_str, sizeof(tok_str), "WapiPsk%d", apidx + 1);						NdisZeroMemory(pAd->ApCfg.MBSSID[apidx].WAPIPassPhrase, 64);			pAd->ApCfg.MBSSID[apidx].WAPIPassPhraseLen = 0;			if(RTMPGetKeyParameter(tok_str, tmpbuf, 65, buffer, FALSE))			{								    			    if (strlen(tmpbuf) >= 8 && strlen(tmpbuf) <= 64)			    {                                    			        NdisMoveMemory(pAd->ApCfg.MBSSID[apidx].WAPIPassPhrase, tmpbuf, strlen(tmpbuf));			        pAd->ApCfg.MBSSID[apidx].WAPIPassPhraseLen = strlen(tmpbuf);   					DBGPRINT(RT_DEBUG_TRACE, ("IF(ra%d) WapiPsk=(%s), len=%d/n", apidx, tmpbuf, strlen(tmpbuf)));									    }				else				{					if (pAd->ApCfg.MBSSID[apidx].AuthMode == Ndis802_11AuthModeWAIPSK)					{						pAd->ApCfg.MBSSID[apidx].AuthMode = Ndis802_11AuthModeOpen;						pAd->ApCfg.MBSSID[apidx].WepStatus = Ndis802_11EncryptionDisabled;					}					DBGPRINT(RT_DEBUG_ERROR, ("IF(ra%d) The length of WAPI PSKPassPhrase is invalid(len=%d). /n", apidx, strlen(tmpbuf)));				}																						}		}						}#endif // CONFIG_AP_SUPPORT //	#ifdef CONFIG_STA_SUPPORT	IF_DEV_CONFIG_OPMODE_ON_STA(pAd)	{		// WapiPsk		if (RTMPGetKeyParameter("WapiPsk", tmpbuf, 512, buffer, FALSE))		{											                 										

//.........这里部分代码省略.........	ptr = lutil_strcopy( ptr, "(&" );	ptr = lutil_strncopy( ptr, li->li_monitor_info.lmi_more_filter.bv_val,		li->li_monitor_info.lmi_more_filter.bv_len );	ptr = lutil_strcopy( ptr, "(monitoredInfo=" );	ptr = lutil_strcopy( ptr, be->bd_info->bi_type );	ptr = lutil_strcopy( ptr, ")(!(monitorOverlay=" );	ptr = lutil_strcopy( ptr, be->bd_info->bi_type );	ptr = lutil_strcopy( ptr, "))(namingContexts:distinguishedNameMatch:=" );	ptr = lutil_strncopy( ptr, suffix.bv_val, suffix.bv_len );	ptr = lutil_strcopy( ptr, "))" );	ptr[ 0 ] = '/0';	assert( ptr == &filter->bv_val[ filter->bv_len ] );	if ( suffix.bv_val != be->be_nsuffix[ 0 ].bv_val ) {		ch_free( suffix.bv_val );	}	now = slap_get_time();	timestamp.bv_val = timebuf;	timestamp.bv_len = sizeof( timebuf );	slap_timestamp( &now, &timestamp );	/* caller (e.g. an overlay based on back-ldap) may want to use	 * a different RDN... */	if ( BER_BVISNULL( &li->li_monitor_info.lmi_rdn ) ) {		ber_str2bv( "cn=Connections", 0, 1, &li->li_monitor_info.lmi_rdn );	}	ptr = ber_bvchr( &li->li_monitor_info.lmi_rdn, '=' );	assert( ptr != NULL );	ptr[ 0 ] = '/0';	ptr++;	snprintf( buf, sizeof( buf ),		"dn: %s=%s/n"		"objectClass: monitorContainer/n"		"%s: %s/n"		"creatorsName: %s/n"		"createTimestamp: %s/n"		"modifiersName: %s/n"		"modifyTimestamp: %s/n",		li->li_monitor_info.lmi_rdn.bv_val,			ptr,		li->li_monitor_info.lmi_rdn.bv_val,			ptr,		BER_BVISNULL( &be->be_rootdn ) ? SLAPD_ANONYMOUS : be->be_rootdn.bv_val,		timestamp.bv_val,		BER_BVISNULL( &be->be_rootdn ) ? SLAPD_ANONYMOUS : be->be_rootdn.bv_val,		timestamp.bv_val );	e = str2entry( buf );	if ( e == NULL ) {		rc = -1;		goto cleanup;	}	ptr[ -1 ] = '=';	/* add labeledURI and special, modifiable URI value */	if ( li->li_uri != NULL ) {		struct berval	bv;		LDAPURLDesc	*ludlist = NULL;		int		rc;		rc = ldap_url_parselist_ext( &ludlist,			li->li_uri, NULL,			LDAP_PVT_URL_PARSE_NOEMPTY_HOST