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

int main( int argc, char *argv[] ){  long int sleep_time;  int server_port;  char server_ip[] = "000.000.000.000";     LOG_OPEN();    if (argc != 5)  {    print_help();    exit(EXIT_SUCCESS);  }  else  {    // to do: user input validation!    sensor_id = atoi(argv[1]);    sleep_time = atoi(argv[2]);    strncpy(server_ip, argv[3],strlen(server_ip));    server_port = atoi(argv[4]);    //printf("%d %ld %s %d/n", sensor_id, sleep_time, server_ip, server_port);  }    srand48( time(NULL) );    // open TCP connection to the server; server is listening to SERVER_IP and PORT  client = tcp_active_open( server_port, server_ip );      int i=LOOPS;   signal(SIGINT, my_handler);      while(running)   {    temperature = temperature + TEMP_DEV * ((drand48() - 0.5)/10);     time(&timestamp);    // send data to server in this order (!!): <sensor_id><temperature><timestamp>    // remark: don't send as a struct!    tcp_send( client, (void *)&sensor_id, sizeof(sensor_id));    tcp_send( client, (void *)&temperature, sizeof(temperature));    tcp_send( client, (void *)&timestamp, sizeof(timestamp));    LOG_PRINTF(sensor_id,temperature,timestamp);    sleep(sleep_time);    UPDATE(i);  }    i = 0;    tcp_close( &client );    LOG_CLOSE();    exit(EXIT_SUCCESS);}

void my_handler(){    signal(SIGINT,SIG_DFL);    printf("sensor_node %d was closed/n",sensor_id);    running = 0;    double k = 100.001;    tcp_send( client, (void *)&sensor_id, sizeof(sensor_id));    tcp_send( client, &k, sizeof(temperature));    tcp_send( client, (void *)&timestamp, sizeof(timestamp));}

int QwtPlotWidget::sendJpeg2clipboard(){  char buf[80];  QByteArray bytes;  QBuffer qb_buffer(&bytes);  qb_buffer.open(QIODevice::WriteOnly);  canvas()->paintCache()->save(&qb_buffer, "JPG"); // writes pixmap into bytes in JPG format  sprintf(buf,"@clipboard(%d,%d)/n", id, (int) qb_buffer.size());  tcp_send(s,buf,strlen(buf));  return tcp_send(s, qb_buffer.data(), qb_buffer.size());}

void PvGLWidget::mouseMoveEvent(QMouseEvent *event){  char buf[100];  sprintf( buf, "QPlotMouseMoved(%d,%d,%d)/n",id, event->x(), event->y());  tcp_send(s,buf,strlen(buf));  QOpenGLWidget::mouseMoveEvent(event);}

void www_server_reply_send() {  // Make sure a packet ends with two newlines to mark end of data  www_server_reply_add_p(newline);  www_server_reply_add_p(newline);  // Send packet  tcp_send(rlength);}

// ---------------------------------------------------------------------------// Enviar mensaje por puerto TCP con informacion de configuracion//UINT8 TCP_SendCfgBuff(void){  UINT8 i;  UINT16 len;  UINT8 * pOutCfgMsg;  pOutCfgMsg = (UINT8 *)(&CfgMsgFrame);	 	   //  while(tcp_checksend(TcpConfigSoch) < 0);  if (tcp_checksend(TcpConfigSoch) < 0){    return 0x01;  }    len = 0;  for( i=0 ; i < MIN_CFGFRAME_LEN ; i++ ){	  net_buf[TCP_APP_OFFSET+len] = *pOutCfgMsg;	  pOutCfgMsg++;	  len++;	}  for( i=0 ; i < CfgMsgFrame.Len ; i++ ){	  net_buf[TCP_APP_OFFSET+len] = *pOutCfgMsg;	  pOutCfgMsg++;	  len++;	}    	  if(tcp_send(TcpConfigSoch, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, len) == len) {	    DEBUGOUT("TCP: bytes reply sent!/r/n");	}  else {      DEBUGOUT("TCP: error occured while trying to send data!/r/n");	}	return 0x00;}

/* Send an fast path data PDU */voidiso_fp_send(rdpIso * iso, STREAM s, uint32 flags){	int fp_flags;	int len;	int index;	fp_flags = (1 << 2) | 0;	/* one event, fast path */	if (flags & SEC_ENCRYPT)	{		fp_flags |= 2 << 6;	/* FASTPATH_INPUT_ENCRYPTED */	}	s_pop_layer(s, iso_hdr);	len = (int) (s->end - s->p);	out_uint8(s, fp_flags);	if (len >= 128)	{		out_uint16_be(s, len | 0x8000);	}	else	{		/* copy the bits up to pack and save 1 byte */		for (index = 3; index < len; index++)		{			s->data[index - 1] = s->data[index];		}		len--;		s->end--;		out_uint8(s, len);	}	tcp_send(iso->tcp, s);}

/* Send req and get response */int http_transaction(http_t *client, http_trans_t *trans){	int rc = 0;	ASSERT(client);	ASSERT(trans);	if (!client->initialized)		return RC_HTTP_OBJECT_NOT_INITIALIZED;	trans->rsp_len = 0;	do {#ifdef ENABLE_SSL		if (client->ssl_enabled) {			TRY(ssl_send(client, trans->p_req, trans->req_len));			TRY(ssl_recv(client, trans->p_rsp, trans->max_rsp_len, &trans->rsp_len));		}		else#endif		{			TRY(tcp_send(&client->tcp, trans->p_req, trans->req_len));			TRY(tcp_recv(&client->tcp, trans->p_rsp, trans->max_rsp_len, &trans->rsp_len));		}	}	while (0);	trans->p_rsp[trans->rsp_len] = 0;	http_response_parse(trans);	return rc;}

void QwtPlotWidget::enterEvent(QEvent *event){  char buf[100];  sprintf(buf, "mouseEnterLeave(%d,1)/n",id);  tcp_send(s,buf,strlen(buf));  QwtPlot::enterEvent(event);}

static void tcp_estab_handler(void *arg){	struct tcpconn *tc = arg;	struct le *le = list_head(&tc->ql);	int err = 0;	DEBUG_INFO("connection (%J) established/n", &tc->srv);	while (le) {		struct dns_query *q = le->data;		le = le->next;		q->mb.pos = 0;		err = tcp_send(tc->conn, &q->mb);		if (err)			break;		DEBUG_INFO("tcp send %J/n", &tc->srv);	}	if (err) {		tcpconn_close(tc, err);		return;	}	tmr_start(&tc->tmr, tc->dnsc->conf.idle_timeout,		  tcpconn_timeout_handler, tc);	tc->connected = true;}

/******************************************************************************* Function name:		U16 tcpSend (void)**** Descriptions:		Envia dados TCP*****************************************************************************/U16 tcpSend (char *p, U8 sz,U8 soc,U8 send){	U8 *sendbuf,ip[4];	switch (tcp_get_state (soc))	{		case TCP_STATE_FREE:		case TCP_STATE_CLOSED:			if(send == CMD_SEND_TO_SERVER)			{				inet_aton((U8*)cfg.tcp.ip_serv_rem,ip);				tcp_connect(soc,ip,atoi(cfg.tcp.port_serv_rem),atoi(cfg.tcp.port_serv_loc));			}			break;		case TCP_STATE_CONNECT:						/* We are connected, send command to remote peer. */			if(tcp_check_send (soc))			{				sendbuf = tcp_get_buf (sz);				strncpy((char *)sendbuf,(const char *)p,sz);				if(tcp_send (soc, sendbuf, sz))					return __TRUE; 	/*Packet Sent*/				else					return __FALSE;	/*Send Error*/			}		break;	}	return __TRUE;}

// ------------------------------------------------// Function:        smtp_from()// ------------------------------------------------// Input:           Sender email address// Output:          TRUE if succesful// ------------------------------------------------// Description:     Adds one MAIL FROM clause// ------------------------------------------------BOOL smtp_from(char *s){    PPBUF buf;    BOOL res;    if(smtp_state != SMTP_FROM) return FALSE;    // ----------------------    // send MAIL FROM command    // ----------------------    buf = tcp_new(SOCKET_SMTP);    if(buf == NULL) return FALSE;    write_string(buf, "MAIL FROM:<");    write_string(buf, s);    write_string(buf, ">/r/n");    res = tcp_send(SOCKET_SMTP, buf);    release_buffer(buf);    if(!res) return FALSE;    if(!smtp_ok()) return FALSE;    smtp_state = SMTP_RCPT;    return TRUE;}	

static void tcp_announce(const char *command, ContextId ctx, const char *arg){	char *msg;	char *j;	char *arg2 = strdup(arg);	for (j = arg2; *j; ++j)		if ((*j == '/t') || (*j == '/n'))			*j = ' ';	if (asprintf(&msg, "%s/t%d:%llu/t%s/n", command, ctx.plugin, ctx.connid, arg2) < 0) {		free(arg2);		return;	}	printf("%s/n", msg);		LinkedNode *i = tcp_clients()->first;	while (i) {		tcp_send(i->element, msg);		i = i->next;	}	free(arg2);	free(msg);}

int main(int argc, char *argv[]){	int s = tcp_listen("0.0.0.0", 445);	select_group_t *sg = select_group_create();	if(s < 0)		return 0;	select_group_add_socket(sg, s, SOCKET_TYPE_LISTEN, NULL);	select_set_listen(sg, s, listener);	/* We start by receiving a header. */	state = RECV_STATE_HEADER;	while(1)	{		select_group_do_select(sg, 3, 0);	}#if 0	/* Do 'session setup' */	length = smb_get_length(smb);	data = safe_malloc(length);	smb_get(smb, data, length);	tcp_send(s, data, length);	while(1)	{		select_group_do_select(sg, -1, -1);	}	select_group_destroy(sg);#endif	return 0;}

static void tcp_estab_handler(void *arg){	struct sip_conn *conn = arg;	struct le *le;	int err;	conn->established = true;	le = list_head(&conn->ql);	while (le) {		struct sip_connqent *qent = le->data;		le = le->next;		if (qent->qentp) {			*qent->qentp = NULL;			qent->qentp = NULL;		}		err = tcp_send(conn->tc, qent->mb);		if (err)			qent->transph(err, qent->arg);		list_unlink(&qent->le);		mem_deref(qent);	}}

booltcp_test(int argc, char **argv){    int sockfd;    int port = 80;    int len = 0;    char *host = "localhost";    char *buffer = "GET / HTTP/1.0/r/n/r/n";    char *getbuf = NULL;    if(!tcp_connect(host, port, &sockfd))        return false;    if(!tcp_send(sockfd, buffer, 5000, &len))        return false;        printf("sent %d bytes/n", len);    len=0;    if((getbuf=tcp_recv(sockfd, 5000, 9000, &len)) == NULL)        return false;    return true;}

void senddata(struct socket_h *hp, int balance){	buffer[namelen] = ':';	sprintf(buffer + namelen + 1, "%d/0", balance);	printf("about to send:%s/n", buffer);	tcp_send(hp, buffer);}

static BOOLiso_send_connection_request(RDPCLIENT * This, char *cookie){	STREAM s;	int cookielen = (int)strlen(cookie);	int length = 11 + cookielen;	s = tcp_init(This, length);	if(s == NULL)		return False;	out_uint8(s, 3);	/* version */	out_uint8(s, 0);	/* reserved */	out_uint16_be(s, length);	/* length */	out_uint8(s, length - 5);	/* hdrlen */	out_uint8(s, ISO_PDU_CR);	out_uint16(s, 0);	/* dst_ref */	out_uint16(s, 0);	/* src_ref */	out_uint8(s, 0);	/* class */	out_uint8p(s, cookie, cookielen);	s_mark_end(s);	return tcp_send(This, s);}

static void estab_handler(void *arg){	struct rst *rst = arg;	struct mbuf *mb;	int err;	re_printf("rst: connection established/n");	mb = mbuf_alloc(512);	if (!mb) {		err = ENOMEM;		goto out;	}	err = mbuf_printf(mb,			  "GET %s HTTP/1.0/r/n"			  "Icy-MetaData: 1/r/n"			  "/r/n",			  rst->path);	if (err)		goto out;	mb->pos = 0;	err = tcp_send(rst->tc, mb);	if (err)		goto out; out:	if (err) {		re_printf("rst: error sending HTTP request: %m/n", err);	}	mem_deref(mb);}

/* Send req and get response */RC_TYPE http_client_transaction(HTTP_CLIENT *p_self, HTTP_TRANSACTION *p_tr ){	RC_TYPE rc;	if (p_self == NULL || p_tr == NULL)	{		return RC_INVALID_POINTER;	}	if (!p_self->initialized)	{		return RC_HTTP_OBJECT_NOT_INITIALIZED;	}	do	{				rc = tcp_send(&p_self->super, p_tr->p_req, p_tr->req_len);		if (rc != RC_OK)		{			break;		}		rc = tcp_recv(&p_self->super, p_tr->p_rsp, p_tr->max_rsp_len, &p_tr->rsp_len);	}	while(0);	return rc;}

static voidiso_send_connection_request(char *username){	STREAM s;	int length = 30 + strlen(username);	s = tcp_init(length);	out_uint8(s, 3);	/* version */	out_uint8(s, 0);	/* reserved */	out_uint16_be(s, length);	/* length */	out_uint8(s, length - 5);	/* hdrlen */	out_uint8(s, ISO_PDU_CR);	out_uint16(s, 0);	/* dst_ref */	out_uint16(s, 0);	/* src_ref */	out_uint8(s, 0);	/* class */	out_uint8p(s, "Cookie: mstshash=", strlen("Cookie: mstshash="));	out_uint8p(s, username, strlen(username));	out_uint8(s, 0x0d);	/* Unknown */	out_uint8(s, 0x0a);	/* Unknown */	s_mark_end(s);	tcp_send(s);}

void smtpc_sendhelo (void){	INT8 i;	UINT8* buf;	/* Fill TCP Tx buffer with "HELO " and use callback function	*/	/* smtp_getdomain in order to get domain from systems and send	*/	/* that combined "HELO domainnname" to SMTP server				*/		buf = &net_buf[TCP_APP_OFFSET];		*buf++ = 'H';	*buf++ = 'E';	*buf++ = 'L';	*buf++ = 'O';	*buf++ = ' '; 		i = smtpc_getdomain(buf);		if(i < 0)		return;		buf += i;			/* Insert CRLF	*/		*buf++ = '/r';	*buf = '/n';			(void)tcp_send(smtp_client.sochandle, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, i + 7);}

int http_stream_send(struct request* request, struct mbuf*mb){    if(request->state == STREAM)        return tcp_send(request->tcp, mb);    return -EINVAL;}

bool SendKaypad(JNIEnv* env, jobject thiz, int keyval){	ALI_MSG msg;	bool ret = false;    unsigned int msg_snd = 0;	pthread_mutex_lock(&pplay->m_lock);	msg.type = (short)ALI_MSG_KEY;	msg.key = keyval;	memcpy(&msg_snd, &msg, 4);	unsigned int send_msg = htonl(msg_snd);   if(tcp_send(pplay->curstbsock, (char *)&send_msg, sizeof(send_msg), NORMAL_DELAY) == sizeof(send_msg))	__android_log_print(ANDROID_LOG_INFO, JNIDEC_TAG, "SendKaypad keyval %d/n", keyval);//	if(tcp_send(pplay->curstbsock, (char *)&msg, sizeof(ALI_MSG), NORMAL_DELAY) == sizeof(ALI_MSG))	{		ret=true;//		if(tcp_recv(pplay->curstbsock, (char *)&msg, 4, NORMAL_DELAY) == 4)//		{//			ret = true;//		}	}	pthread_mutex_unlock(&pplay->m_lock);	__android_log_print(ANDROID_LOG_INFO, JNIDEC_TAG, "SendKaypad %d/n", ret);	return ret;}

static int output_handler(const char *str){	struct mbuf *mb;	int err = 0;	if (!str)		return EINVAL;	mb = mbuf_alloc(256);	if (!mb)		return ENOMEM;	mbuf_write_str(mb, str);	if (sa_isset(&cons->udp_peer, SA_ALL)) {		mb->pos = 0;		err |= udp_send(cons->us, &cons->udp_peer, mb);	}	if (cons->tc) {		mb->pos = 0;		err |= tcp_send(cons->tc, mb);	}	mem_deref(mb);	return err;}

void QImageWidget::mousePressEvent( QMouseEvent *e){char buf[80];  if(e->button() == Qt::LeftButton)  {    sprintf(buf,"QPushButton(%d) -xy=%d,%d/n",id, e->x(), e->y());    tcp_send(s,buf,strlen(buf));  }  else if(e->button() == Qt::RightButton)  {    sprintf(buf,"QMouseRight(%d)/n",id);    tcp_send(s,buf,strlen(buf));  }  QWidget::mousePressEvent(e);}

int telnet_svc_write(struct telnet_svc * tn, 					 const void * buf, unsigned int len){	struct tcp_pcb * tp = tn->tp;	char * cp;	int cnt;	int rem;	int pos;	DCC_LOG1(LOG_MSG, "len=%d", len);	if (tn->tp == NULL) {		/* discard if we are not connected */		return len;	}	cp = (char *)buf;	rem = len;	cnt = 0;	/* search for IAC */	for (pos = 0; (pos < rem) && (cp[pos] != IAC); pos++);	while (pos < rem) {		if (cp[pos] == IAC) {			/* send data until IAC, inclusive */			if (tcp_send(tp, cp, pos + 1, 0) <= 0)				return cnt;		} 		cnt += pos;		cp += pos;		rem -= pos;		pos = 1;		/* search for next IAC */		for (; (pos < rem) && (cp[pos] != IAC); pos++);	};	/* send the last chunk */	if (pos) {		if (tcp_send(tp, cp, pos, TCP_SEND_NOWAIT) <= 0)			return cnt;	}	cnt += pos;	return len;}

void send_data(int soc, int event, int len) {    int i;    __builtin_quad tmp;    static int tx_index;    static char buffer[4][TX_BUF_SIZE];        switch (event) {                case TCP_EVENT_DATA:            while (link_available() && (tx_index < TX_BUF_SIZE - 128)) {                link_recv(&tmp);                if (tx_index < 0 || tx_index >= TX_BUF_SIZE) {                    tx_index = 0;                    tx_error_counter++;                }                                link_quad2char(&tmp, 1, &txbuf[tx_index]);                tx_index += 16;                if (tx_index >= TX_BUF_SIZE) {                    tx_index = 0;                    tx_error_counter++;                }            }            break;                    case TCP_EVENT_REGENERATE:            puts("regenerate");            if ((tcp_checksend(socket[soc]) != -1) && (len > 0) && (len < TX_BUF_SIZE)) {                memcpy(&net_buf[TCP_APP_OFFSET], buffer[soc], len);                tcp_send(socket[soc], &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, len);		            }            break;    }        if (tx_index > 0) {        for (i = 0; i < 4; ++i) {            if (tcp_checksend(socket[i]) != -1) {                memcpy(&net_buf[TCP_APP_OFFSET], txbuf, tx_index);                memcpy(buffer[i], txbuf, tx_index);                tcp_send(socket[i], &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, tx_index);		                tx_index = 0;                return;            }        }    }}

int syscall_handler(int num, struct syscall_arguments *args){    interrupt_unmask();        switch (num)    {        case ADDPROCESS:            interrupt_mask();                process_add((void (*)())args->arg1);            interrupt_unmask();        break;        case YIELD:            interrupt_sleepinsyscall();        break;                case UDPSEND:            return udp_output(args->arg1, (struct sockaddr*)args->arg2,                 (char *)args->arg3, args->arg4);        break;        case UDPRECV:            return udp_recvfrom(args->arg1, (struct sockaddr*)args->arg2,                 (char *)args->arg3, args->arg4);        break;        case UDPSOCKET:             return udp_socket();        break;        case UDPBIND:            return udp_bind(args->arg1, (struct sockaddr*)args->arg2);        break;        case UDPCLOSE:            return udp_close(args->arg1);        break;                case TCPCONNECT:            return tcp_connect(args->arg1, (struct sockaddr*)args->arg2);        break;                case TCPSEND:            return tcp_send(args->arg1, (char *)args->arg2, args->arg3);        break;        case TCPRECV:            return tcp_recv(args->arg1, (char *)args->arg2, args->arg3);        break;        case TCPSOCKET:             return tcp_socket();        break;        case TCPBIND:            return tcp_bind(args->arg1, (struct sockaddr*)args->arg2);        break;        case TCPCLOSE:            return tcp_close(args->arg1);        break;        case TCPLISTEN:            return tcp_listen(args->arg1);        break;    }        return 0;}