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

/* * token ID                1 byte * audit ID                4 bytes * effective user ID       4 bytes * effective group ID      4 bytes * real user ID            4 bytes * real group ID           4 bytes * process ID              4 bytes * session ID              4 bytes * terminal ID *   port ID               4 bytes/8 bytes (32-bit/64-bit value) *   machine address       4 bytes */token_t *au_to_process32(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid,    pid_t pid, au_asid_t sid, au_tid_t *tid){	token_t *t;	u_char *dptr = NULL;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 9 * sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_PROCESS32);	ADD_U_INT32(dptr, auid);	ADD_U_INT32(dptr, euid);	ADD_U_INT32(dptr, egid);	ADD_U_INT32(dptr, ruid);	ADD_U_INT32(dptr, rgid);	ADD_U_INT32(dptr, pid);	ADD_U_INT32(dptr, sid);	ADD_U_INT32(dptr, tid->port);	/*	 * Note: Solaris will write out IPv6 addresses here as a 32-bit	 * address type and 16 bytes of address, but for IPv4 addresses it	 * simply writes the 4-byte address directly.  We support only IPv4	 * addresses for process32 tokens.	 */	ADD_MEM(dptr, &tid->machine, sizeof(u_int32_t));	return (t);}

/* * token ID                1 byte * owner user ID           4 bytes * owner group ID          4 bytes * creator user ID         4 bytes * creator group ID        4 bytes * access mode             4 bytes * slot sequence #         4 bytes * key                     4 bytes */token_t *au_to_ipc_perm(struct ipc_perm *perm){	token_t *t;	u_char *dptr = NULL;	u_int16_t pad0 = 0;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 12 * sizeof(u_int16_t) +	    sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_IPC_PERM);	/*	 * Systems vary significantly in what types they use in struct	 * ipc_perm; at least a few still use 16-bit uid's and gid's, so	 * allow for that, as BSM define 32-bit values here.	 * Some systems define the sizes for ipc_perm members as 2 bytes;	 * BSM defines 4 so pad with 0.	 *	 * XXXRW: Possibly shoulid be conditionally compiled, and more cases	 * need to be handled.	 */	if (sizeof(perm->uid) != sizeof(u_int32_t)) {		ADD_U_INT16(dptr, pad0);		ADD_U_INT16(dptr, perm->uid);		ADD_U_INT16(dptr, pad0);		ADD_U_INT16(dptr, perm->gid);		ADD_U_INT16(dptr, pad0);		ADD_U_INT16(dptr, perm->cuid);		ADD_U_INT16(dptr, pad0);		ADD_U_INT16(dptr, perm->cgid);	} else {		ADD_U_INT32(dptr, perm->uid);		ADD_U_INT32(dptr, perm->gid);		ADD_U_INT32(dptr, perm->cuid);		ADD_U_INT32(dptr, perm->cgid);	}	ADD_U_INT16(dptr, pad0);	ADD_U_INT16(dptr, perm->mode);	ADD_U_INT16(dptr, pad0);	ADD_U_INT16(dptr, perm->seq);	ADD_U_INT32(dptr, perm->key);	return (t);}

/* * token ID				1 byte * count				4 bytes * text					count null-terminated strings */token_t *au_to_exec_args(char **argv){	token_t *t;	u_char *dptr = NULL;	const char *nextarg;	int i, count = 0;	size_t totlen = 0;	nextarg = *argv;	while (nextarg != NULL) {		int nextlen;		nextlen = strlen(nextarg);		totlen += nextlen + 1;		count++;		nextarg = *(argv + count);	}	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) + totlen);	ADD_U_CHAR(dptr, AUT_EXEC_ARGS);	ADD_U_INT32(dptr, count);	for (i = 0; i < count; i++) {		nextarg = *(argv + i);		ADD_MEM(dptr, nextarg, strlen(nextarg) + 1);	}	return (t);}

/* * token ID				1 byte * count				4 bytes * text					count null-terminated strings */token_t *au_to_exec_env(char **envp){	token_t *t;	u_char *dptr = NULL;	int i, count = 0;	size_t totlen = 0;	const char *nextenv;	nextenv = *envp;	while (nextenv != NULL) {		int nextlen;		nextlen = strlen(nextenv);		totlen += nextlen + 1;		count++;		nextenv = *(envp + count);	}	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) + totlen);	ADD_U_CHAR(dptr, AUT_EXEC_ENV);	ADD_U_INT32(dptr, count);	for (i = 0; i < count; i++) {		nextenv = *(envp + i);		ADD_MEM(dptr, nextenv, strlen(nextenv) + 1);	}	return (t);}

token_t *au_to_attr64(struct vnode_au_info *vni){	token_t *t;	u_char *dptr = NULL;	u_int16_t pad0_16 = 0;	u_int32_t pad0_32 = 0;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(u_int16_t) +	    3 * sizeof(u_int32_t) + sizeof(u_int64_t) * 2);	ADD_U_CHAR(dptr, AUT_ATTR64);	/*	 * BSD defines the size for the file mode as 2 bytes; BSM defines 4	 * so pad with 0.	 *	 * XXXRW: Possibly should be conditionally compiled.	 *	 * XXXRW: Should any conversions take place on the mode?	 */	ADD_U_INT16(dptr, pad0_16);	ADD_U_INT16(dptr, vni->vn_mode);	ADD_U_INT32(dptr, vni->vn_uid);	ADD_U_INT32(dptr, vni->vn_gid);	ADD_U_INT32(dptr, vni->vn_fsid);	/*	 * Some systems use 32-bit file ID's, other's use 64-bit file IDs.	 * Attempt to handle both, and let the compiler sort it out.  If we	 * could pick this out at compile-time, it would be better, so as to	 * avoid the else case below.	 */	if (sizeof(vni->vn_fileid) == sizeof(uint32_t)) {		ADD_U_INT32(dptr, pad0_32);		ADD_U_INT32(dptr, vni->vn_fileid);	} else if (sizeof(vni->vn_fileid) == sizeof(uint64_t))		ADD_U_INT64(dptr, vni->vn_fileid);	else		ADD_U_INT64(dptr, 0LL);	ADD_U_INT64(dptr, vni->vn_dev);	return (t);}

token_t *kau_to_socket(struct socket_au_info *soi){	token_t *t;	u_char *dptr;	u_int16_t so_type;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(u_int16_t) +	    sizeof(u_int32_t) + sizeof(u_int16_t) + sizeof(u_int32_t));                                                 	ADD_U_CHAR(dptr, AUT_SOCKET);	/* Coerce the socket type into a short value */	so_type = soi->so_type;	ADD_U_INT16(dptr, so_type);	ADD_U_INT16(dptr, soi->so_lport);	ADD_U_INT32(dptr, soi->so_laddr);	ADD_U_INT16(dptr, soi->so_rport);	ADD_U_INT32(dptr, soi->so_raddr);	return (t);}

/* * token ID                1 byte * sequence number         4 bytes */token_t *au_to_seq(long audit_count){	token_t *t;	u_char *dptr = NULL;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_SEQ);	ADD_U_INT32(dptr, audit_count);	return (t);}

/* * token ID                1 byte * object ID type          1 byte * object ID               4 bytes */token_t *au_to_ipc(char type, int id){	token_t *t;	u_char *dptr = NULL;	GET_TOKEN_AREA(t, dptr, 2 * sizeof(u_char) + sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_IPC);	ADD_U_CHAR(dptr, type);	ADD_U_INT32(dptr, id);	return (t);}

/* * token ID                1 byte * error status            1 byte * return value            4 bytes/8 bytes (32-bit/64-bit value) */token_t *au_to_return32(char status, u_int32_t ret){	token_t *t;	u_char *dptr = NULL;	GET_TOKEN_AREA(t, dptr, 2 * sizeof(u_char) + sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_RETURN32);	ADD_U_CHAR(dptr, status);	ADD_U_INT32(dptr, ret);	return (t);}

/* * token ID                1 byte * seconds of time         4 bytes * milliseconds of time    4 bytes * file name len           2 bytes * file pathname           N bytes + 1 terminating NULL byte */token_t *au_to_file(const char *file, struct timeval tm){	token_t *t;	u_char *dptr = NULL;	u_int16_t filelen;	u_int32_t timems;	filelen = strlen(file);	filelen += 1;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(u_int32_t) +	    sizeof(u_int16_t) + filelen);	timems = tm.tv_usec/1000;	ADD_U_CHAR(dptr, AUT_OTHER_FILE32);	ADD_U_INT32(dptr, tm.tv_sec);	ADD_U_INT32(dptr, timems);	/* We need time in ms. */	ADD_U_INT16(dptr, filelen);	ADD_STRING(dptr, file, filelen);	return (t);}

/* * token ID                1 byte * address type/length     4 bytes * address                16 bytes */token_t *au_to_in_addr_ex(struct in6_addr *internet_addr){	token_t *t;	u_char *dptr = NULL;	u_int32_t type = AU_IPv6;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 5 * sizeof(uint32_t));	ADD_U_CHAR(dptr, AUT_IN_ADDR_EX);	ADD_U_INT32(dptr, type);	ADD_MEM(dptr, internet_addr, 4 * sizeof(uint32_t));	return (t);}

/* * token ID                1 byte * record byte count       4 bytes * version #               1 byte    [2] * event type              2 bytes * event modifier          2 bytes * seconds of time         4 bytes/8 bytes (32-bit/64-bit value) * milliseconds of time    4 bytes/8 bytes (32-bit/64-bit value) */token_t *au_to_header32_tm(int rec_size, au_event_t e_type, au_emod_t e_mod,    struct timeval tm){	token_t *t;	u_char *dptr = NULL;	u_int32_t timems;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) +	    sizeof(u_char) + 2 * sizeof(u_int16_t) + 2 * sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_HEADER32);	ADD_U_INT32(dptr, rec_size);	ADD_U_CHAR(dptr, AUDIT_HEADER_VERSION_OPENBSM);	ADD_U_INT16(dptr, e_type);	ADD_U_INT16(dptr, e_mod);	timems = tm.tv_usec/1000;	/* Add the timestamp */	ADD_U_INT32(dptr, tm.tv_sec);	ADD_U_INT32(dptr, timems);	/* We need time in ms. */	return (t);}

/* * token ID                1 byte * trailer magic number    2 bytes * record byte count       4 bytes */token_t *au_to_trailer(int rec_size){	token_t *t;	u_char *dptr = NULL;	u_int16_t magic = AUT_TRAILER_MAGIC;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) +	    sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_TRAILER);	ADD_U_INT16(dptr, magic);	ADD_U_INT32(dptr, rec_size);	return (t);}

/* * token ID                1 byte * number groups           2 bytes * group list              count * 4 bytes */token_t *au_to_newgroups(u_int16_t n, gid_t *groups){	token_t *t;	u_char *dptr = NULL;	int i;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) +	    n * sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_NEWGROUPS);	ADD_U_INT16(dptr, n);	for (i = 0; i < n; i++)		ADD_U_INT32(dptr, groups[i]);	return (t);}

/* * token ID                1 byte * audit ID                4 bytes * effective user ID       4 bytes * effective group ID      4 bytes * real user ID            4 bytes * real group ID           4 bytes * process ID              4 bytes * session ID              4 bytes * terminal ID *   port ID               4 bytes/8 bytes (32-bit/64-bit value) *   machine address       4 bytes */token_t *au_to_subject32(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid,    pid_t pid, au_asid_t sid, au_tid_t *tid){	token_t *t;	u_char *dptr = NULL;	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 9 * sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_SUBJECT32);	ADD_U_INT32(dptr, auid);	ADD_U_INT32(dptr, euid);	ADD_U_INT32(dptr, egid);	ADD_U_INT32(dptr, ruid);	ADD_U_INT32(dptr, rgid);	ADD_U_INT32(dptr, pid);	ADD_U_INT32(dptr, sid);	ADD_U_INT32(dptr, tid->port);	ADD_MEM(dptr, &tid->machine, sizeof(u_int32_t));	return (t);}

/* * token ID                1 byte * argument #              1 byte * argument value          4 bytes/8 bytes (32-bit/64-bit value) * text length             2 bytes * text                    N bytes + 1 terminating NULL byte */token_t *au_to_arg32(char n, const char *text, u_int32_t v){	token_t *t;	u_char *dptr = NULL;	u_int16_t textlen;	textlen = strlen(text);	textlen += 1;	GET_TOKEN_AREA(t, dptr, 2 * sizeof(u_char) + sizeof(u_int32_t) +	    sizeof(u_int16_t) + textlen);	ADD_U_CHAR(dptr, AUT_ARG32);	ADD_U_CHAR(dptr, n);	ADD_U_INT32(dptr, v);	ADD_U_INT16(dptr, textlen);	ADD_STRING(dptr, text, textlen);	return (t);}

token_t *au_to_process64_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid,    gid_t rgid, pid_t pid, au_asid_t sid, au_tid_addr_t *tid){	token_t *t;	u_char *dptr = NULL;	if (tid->at_type == AU_IPv4)		GET_TOKEN_AREA(t, dptr, sizeof(u_char) +		    7 * sizeof(u_int32_t) + sizeof(u_int64_t) +		    2 * sizeof(u_int32_t));	else if (tid->at_type == AU_IPv6)		GET_TOKEN_AREA(t, dptr, sizeof(u_char) +		    7 * sizeof(u_int32_t) + sizeof(u_int64_t) +		    5 * sizeof(u_int32_t));	else		panic("au_to_process64_ex: invalidate at_type (%d)",		    tid->at_type);	ADD_U_CHAR(dptr, AUT_PROCESS64_EX);	ADD_U_INT32(dptr, auid);	ADD_U_INT32(dptr, euid);	ADD_U_INT32(dptr, egid);	ADD_U_INT32(dptr, ruid);	ADD_U_INT32(dptr, rgid);	ADD_U_INT32(dptr, pid);	ADD_U_INT32(dptr, sid);	ADD_U_INT64(dptr, tid->at_port);	ADD_U_INT32(dptr, tid->at_type);	ADD_MEM(dptr, &tid->at_addr[0], sizeof(u_int32_t));	if (tid->at_type == AU_IPv6) {		ADD_MEM(dptr, &tid->at_addr[1], sizeof(u_int32_t));		ADD_MEM(dptr, &tid->at_addr[2], sizeof(u_int32_t));		ADD_MEM(dptr, &tid->at_addr[3], sizeof(u_int32_t));	}	return (t);}

token_t *au_to_subject64_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid,    gid_t rgid, pid_t pid, au_asid_t sid, au_tid_addr_t *tid){	token_t *t;	u_char *dptr = NULL;	KASSERT((tid->at_type == AU_IPv4) || (tid->at_type == AU_IPv6),	    ("au_to_subject64_ex: type %u", (unsigned int)tid->at_type));	if (tid->at_type == AU_IPv4)		GET_TOKEN_AREA(t, dptr, sizeof(u_char) +		    7 * sizeof(u_int32_t) + sizeof(u_int64_t) +		    2 * sizeof(u_int32_t));	else		GET_TOKEN_AREA(t, dptr, sizeof(u_char) +		    7 * sizeof(u_int32_t) + sizeof(u_int64_t) +		    5 * sizeof(u_int32_t));	ADD_U_CHAR(dptr, AUT_SUBJECT64_EX);	ADD_U_INT32(dptr, auid);	ADD_U_INT32(dptr, euid);	ADD_U_INT32(dptr, egid);	ADD_U_INT32(dptr, ruid);	ADD_U_INT32(dptr, rgid);	ADD_U_INT32(dptr, pid);	ADD_U_INT32(dptr, sid);	ADD_U_INT64(dptr, tid->at_port);	ADD_U_INT32(dptr, tid->at_type);	if (tid->at_type == AU_IPv6)		ADD_MEM(dptr, &tid->at_addr[0], 4 * sizeof(u_int32_t));	else		ADD_MEM(dptr, &tid->at_addr[0], sizeof(u_int32_t));	return (t);}

static token_t *au_to_exec_strings(char *strs, int count, u_char type){	token_t *t;	u_char *dptr = NULL;	u_int32_t totlen;	int ctr;	char *p;	totlen = 0;	ctr = count;	p = strs;	while (ctr-- > 0) {		totlen += strlen(p) + 1;		p = strs + totlen;	}	GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) + totlen);	ADD_U_CHAR(dptr, type);	ADD_U_INT32(dptr, count);	ADD_STRING(dptr, strs, totlen);	return (t);}