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

static void send_response(wurfld_connection_context *ctx) {    char *useragent = ctx->useragent;    DEBUG1("Worker %p is looking up useragent : %s", pthread_self(), useragent);    // this might be unnecessary if libwurfl is thread-safe    // XXX - needs to be checked    wurfld_get_capabilities(useragent, ctx->output);    if (use_http) {        char response_header[1024];        sprintf(response_header, "%s 200 OK/r/n"                "Content-Type: application/json/r/n"                "Content-length: %d/r/n"                "Server: wurfld/r/n"                "Connection: Close/r/n/r/n",                ctx->is_http10 ? "HTTP/1.0" : "HTTP/1.1", fbuf_used(ctx->output));        int err = write_socket(ctx->fd, response_header, strlen(response_header));        if (err != 0) {            ERROR("(%p) Can't write the response header : %s", pthread_self(), strerror(errno));        }    }    if (write_socket(ctx->fd, fbuf_data(ctx->output), fbuf_used(ctx->output)) != 0) {        ERROR("(%p) Can't write the response data : %s", pthread_self(), strerror(errno));    }}

/*	Sends the group at group_index to the user on the socket provided*/void send_group(int group_index, int socket){	char message[2048];	memset(message,'/0',sizeof(message));	strcat(message,"S");	int i;	struct chat_group *cg = all_groups[group_index];	printf("Number of users in this group, server side: %d/n",cg->num_users); 	//First, send the number of users that are in the group:	int network_num_users = htonl(cg->num_users);	write_socket(socket,&network_num_users,sizeof(int));	//Next, send the message with the users:	for(i = 0; i < cg->num_users; ++i){		strcat(message,":");		strcat(message,cg->users[i]->username);		strcat(message,":");		strcat(message,cg->users[i]->IP);	}	strcat(message,"::");	//printf("Message to send: %s/n", message);	//Send the size of the message	int network_message_size = htonl(sizeof(message));	write_socket(socket,&network_message_size,sizeof(int));	//Send the message itself	write_socket(socket,message,sizeof(message));}

void KCrash::startDrKonqi(const char *argv[], int argc){    int socket = openSocket();    if(socket < -1)    {        startDirectly(argv, argc);        return;    }    klauncher_header header;    header.cmd = LAUNCHER_EXEC_NEW;    const int BUFSIZE = 8192; // make sure this is big enough    char buffer[BUFSIZE + 10];    int pos = 0;    long argcl = argc;    memcpy(buffer + pos, &argcl, sizeof(argcl));    pos += sizeof(argcl);    for(int i = 0; i < argc; ++i)    {        int len = strlen(argv[i]) + 1; // include terminating /0        if(pos + len > BUFSIZE)        {            fprintf(stderr, "BUFSIZE in KCrash not big enough!/n");            startDirectly(argv, argc);            return;        }        memcpy(buffer + pos, argv[i], len);        pos += len;    }    long env = 0;    memcpy(buffer + pos, &env, sizeof(env));    pos += sizeof(env);    long avoid_loops = 0;    memcpy(buffer + pos, &avoid_loops, sizeof(avoid_loops));    pos += sizeof(avoid_loops);    header.arg_length = pos;    write_socket(socket, (char *)&header, sizeof(header));    write_socket(socket, buffer, pos);    if(read_socket(socket, (char *)&header, sizeof(header)) < 0 || header.cmd != LAUNCHER_OK)    {        startDirectly(argv, argc);        return;    }    long pid;    read_socket(socket, buffer, header.arg_length);    pid = *((long *)buffer);    alarm(0); // Seems we made it....    for(;;)    {        if(kill(pid, 0) < 0)            _exit(253);        sleep(1);        // the debugger should stop this process anyway    }}

/*	This function accepts a socket as a parameter and sends the list of current groups to that socket.*/void send_list(int socket) {	// First, send an int of the total number of groups	int network_num_groups = htonl(num_groups);	write_socket(socket,&network_num_groups,sizeof(int));	//Next, go through all of the groups and send them to the user.	int i;	for(i = 0; i < num_groups; i++){		write_socket(socket,all_groups[i]->groupname, NAME_SIZE);	}}

int Cmd_operater(int sockd){	char cmd[7],message[256];	int i;	int flag=0;    char buffer[512];    char send_buffer[512];	while(1)	{		if(timeout(sockd,200)>0)		{			    memset(buffer,'/0',512);		    memset(send_buffer,'/0',512);                        read_socket(sockd,buffer,512);		            printf("recv:%s/n",buffer);            sprintf(send_buffer,"server recv:%s/n",buffer);            write_socket(sockd,send_buffer,512);		}		else		{				close(sockd);				break;		}	}}

BOOLsend_null_session_msg (int fd){    ssize_t ret;    uint32 blank = 0;    size_t len = 4;    size_t nwritten = 0;    char *buffer = (char *) &blank;    while (nwritten < len)    {        ret = write_socket (fd, buffer + nwritten, len - nwritten);        if (ret <= 0)        {            DEBUG (0,                   ("send_null_session_msg: Error writing %d bytes to client. %d. Exiting/n",                    (int) len, (int) ret));            close_sockets ();            exit (1);        }        nwritten += ret;    }    DEBUG (10, ("send_null_session_msg: sent 4 null bytes to client./n"));    return True;}

/* * Function name: time_out * Description  : Called after some time to close the connection. */static voidtime_out(){    write_socket("Application time out./n");    destruct();}

/* * Function name: catch_tell * Description:   This is the text that normal players gets written to *                their sockets. */voidcatch_tell(string str){    int il;    string pattern, func, euid;    if (query_interactive(this_object())) // Monster is possessed    {	write_socket(str);	return;    }    if (!sizeof(trig_patterns))	return;    cur_text = str;    for (il = 0; il < sizeof(trig_patterns); il++)    {	if (stringp(trig_patterns[il])) 	{	    pattern = process_string(trig_patterns[il], 1);	    if (trig_check(str, pattern, trig_functions[il]))		return;	}    }}

/* * Function name: quit * Description  : Remove the object from memory when the player aborts. */static voidquit(){    write_socket("/nAborting application./n");    destruct();}

static void telnet_send_naws(struct session *ses){    unsigned char nego[128], *np;#define PUTBYTE(b)    if ((b)==255) *np++=255;   *np++=(b);    np=nego;    *np++=IAC;    *np++=SB;    *np++=NAWS;    PUTBYTE(COLS/256);    PUTBYTE(COLS%256);    PUTBYTE((LINES-1-!!isstatus)/256);    PUTBYTE((LINES-1-!!isstatus)%256);    *np++=IAC;    *np++=SE;    write_socket(ses, (char*)nego, np-nego);#ifdef TELNET_DEBUG    {        char buf[BUFFER_SIZE], *b=buf;        int neb=np-nego-2;        np=nego+3;        b=buf+sprintf(buf, "IAC SB NAWS ");        while (np-nego<neb)            b+=sprintf(b, "<%u> ", *np++);        b+=sprintf(b, "IAC SE");        tintin_printf(ses, "~8~[telnet] sent: %s~-1~", buf);    }#endif}

static void telnet_send_ttype(struct session *ses){    char nego[128];    const char *ttype;    switch (ses->last_term_type++)    {    case 0:        ttype=TERM;        break;    case 1:        ttype="hardcopy";        break;    case 2:        ttype="unknown";        break;    /* contrary to what zMud does, we cannot claim we're "vt100" or "ansi", */    /* as we obviously lack an addressable cursor */    default:        ses->last_term_type=0;    case 3:        ttype="KBtin-"VERSION;    }    write_socket(ses, nego,        sprintf(nego, "%c%c%c%c%s%c%c", IAC, SB,            TERMINAL_TYPE, IS, ttype, IAC, SE));#ifdef TELNET_DEBUG    tintin_printf(ses, "~8~[telnet] sent: IAC SB TERMINAL-TYPE IS /"%s/" IAC SE~-1~", ttype);#endif}

intsend_request(Request req){	if (! req->socket ) {		req->socket = connect_socket(req->host,req->port,0);		if (! req->socket) {			error("Failed to connect to %s:%i/n",req->host,req->port);			return 0;		}		add_req_socket(req->socket->fd);		return 0;	}	if (req->length < 0) {		str cmd = _("%s %s HTTP/1.1/r/n",req->method,req->path);		write_socket(req->socket,cmd);		request_headers(req,_("Host"),req->host);		send_headers(req->socket,req->headers);		req->length = outbound_content_length(req->contents,req->raw_contents);			return req->contents != NULL || req->raw_contents != NULL ;	}	req->written += req->contents ?			send_contents(req->socket,req->contents,is_chunked(req->headers)) :		req->raw_contents ?			send_raw_contents(req->socket,req->raw_contents,req->written,0):			0;	if (is_chunked(req->headers) && req->written >= req->length)		write_chunk(req->socket,NULL,0);	return req->written < req->length;}

intvprintln_socket(NDB_SOCKET_TYPE socket, int timeout_millis, 		const char * fmt, va_list ap){  char buf[1000];  char *buf2 = buf;  size_t size;  if (fmt != 0 && fmt[0] != 0) {    size = BaseString::vsnprintf(buf, sizeof(buf), fmt, ap)+1;// extra byte for '/n'    /* Check if the output was truncated */    if(size > sizeof(buf)) {      buf2 = (char *)malloc(size);      if(buf2 == NULL)	return -1;      BaseString::vsnprintf(buf2, size, fmt, ap);    }  } else {    size = 1;  }  buf2[size-1]='/n';  int ret = write_socket(socket, timeout_millis, buf2, size);  if(buf2 != buf)    free(buf2);  return ret;}

BOOL cli_send_smb(struct cli_state *cli){	size_t len;	size_t nwritten=0;	ssize_t ret;	/* fd == -1 causes segfaults -- Tom ([email
C++ write_status函数代码示例
C++ write_seqlock函数代码示例