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

BOOL ClientAuthenticate(const char *name, const char *hostname){	int rc, rcISC;	SEC_WINNT_AUTH_IDENTITY nameAndPwd = {0};	int bytesReceived = 0, bytesSent = 0;	char myTokenSource[256];	TimeStamp useBefore;	DWORD ctxReq, ctxAttr;	int dwRead,dwWritten;	// input and output buffers	SecBufferDesc obd, ibd;	SecBuffer ob, ib[2];	BOOL haveInbuffer = FALSE;	BOOL haveContext = FALSE;	SCHANNEL_CRED cred = {0};	PCCERT_CONTEXT cert = NULL;	HANDLE hMy = CertOpenSystemStore(0,"MY");	if(!hMy)	{		rcISC = SEC_E_NO_CREDENTIALS;		server_error(1,"[%08x] %s/n",rcISC,GetErrorString(rcISC));		return FALSE;    }	if(name)	{		cert = CertFindCertificateInStore(hMy, X509_ASN_ENCODING, 0, CERT_FIND_SUBJECT_STR, (const wchar_t *)cvs::wide(name),	NULL);		if(!cert)		{			rcISC = SEC_E_NO_CREDENTIALS;			server_error(1,"No certificate for '%s': %s/n",name,GetErrorString(rcISC));			return FALSE;		}	}	cred.dwVersion = SCHANNEL_CRED_VERSION;	cred.dwFlags = SCH_CRED_USE_DEFAULT_CREDS;	if(cert)	{		cred.cCreds     = 1;		cred.paCred     = &cert;	}	rc = AcquireCredentialsHandle( NULL, "SChannel", SECPKG_CRED_OUTBOUND, NULL, &cred, NULL, NULL, &credHandle, &useBefore );	ctxReq = ISC_REQ_MANUAL_CRED_VALIDATION | ISC_REQ_INTEGRITY | ISC_REQ_CONFIDENTIALITY | ISC_REQ_REPLAY_DETECT | ISC_REQ_SEQUENCE_DETECT | ISC_REQ_STREAM | ISC_REQ_USE_SUPPLIED_CREDS;	strncpy(myTokenSource,hostname,sizeof(myTokenSource));	CertCloseStore(hMy,0);	ib[0].pvBuffer = NULL;	while ( 1 )	{		obd.ulVersion = SECBUFFER_VERSION;		obd.cBuffers = 1;		obd.pBuffers = &ob; // just one buffer		ob.BufferType = SECBUFFER_TOKEN; // preping a token here		ob.cbBuffer = secPackInfo->cbMaxToken;		ob.pvBuffer = malloc(secPackInfo->cbMaxToken);		rcISC = InitializeSecurityContext( &credHandle, haveContext? &contextHandle: NULL,			myTokenSource, ctxReq, 0, SECURITY_NATIVE_DREP, haveInbuffer? &ibd: NULL,			0, &contextHandle, &obd, &ctxAttr, &useBefore );		if ( ib[0].pvBuffer != NULL )		{			free(ib[0].pvBuffer);			ib[0].pvBuffer = NULL;		}		if ( rcISC == SEC_I_COMPLETE_AND_CONTINUE || rcISC == SEC_I_COMPLETE_NEEDED )		{			CompleteAuthToken( &contextHandle, &obd );			if ( rcISC == SEC_I_COMPLETE_NEEDED )				rcISC = SEC_E_OK;			else if ( rcISC == SEC_I_COMPLETE_AND_CONTINUE )				rcISC = SEC_I_CONTINUE_NEEDED;		}		if(rcISC<0)		{			server_error(1,"[%08x] %s/n",rcISC,GetErrorString(rcISC));		}		// send the output buffer off to the server		if ( ob.cbBuffer != 0 )		{			if((dwWritten=tcp_write( (const char *) ob.pvBuffer, ob.cbBuffer))<=0)				break;			bytesSent += dwWritten;		}		free(ob.pvBuffer);		ob.pvBuffer = NULL;		ob.cbBuffer = 0;		if ( rcISC != SEC_I_CONTINUE_NEEDED )			break;//.........这里部分代码省略.........

static int echo_worker(void *socket){    tcp_socket_t *s = socket;    for (;;) {        uint8_t buf[1024];        ssize_t ret = tcp_read(s, buf, sizeof(buf));        if (ret <= 0)            break;        tcp_write(s, buf, ret);        if (ret <= 0)            break;    }    TRACEF("echo worker exiting/n");    tcp_close(s);    return 0;}

static void 	TCP_send(struct tcp_pcb *tpcb, TCP *es) {		struct pbuf *ptr;		err_t wr_err = ERR_OK;	 		while ((wr_err == ERR_OK) &&					 (es->tx != NULL) && 					 (es->tx->len <= tcp_sndbuf(tpcb)))		{			ptr=es->tx;																	/* get pointer on pbuf from es structure & enqueue data for transmission */			wr_err=tcp_write(tpcb,ptr->payload,ptr->len, 1);			if (wr_err == ERR_OK) {				es->tx = ptr->next;				if (es->tx != NULL) {					pbuf_ref(es->tx); 											/* increment reference count for es->p */				}				pbuf_free(ptr);														/* free pbuf: will free pbufs up to es->p (because es->p has a reference count > 0) */			} else if(wr_err == ERR_MEM) { 							/* we are low on memory, try later / harder, defer to poll */				es->tx = ptr;		 } else { }																		/* other problem ?? */		}	}

static int mg_lwip_tcp_write(struct tcp_pcb *tpcb, const void *data,                             uint16_t len) {  len = MIN(tpcb->mss, MIN(len, tpcb->snd_buf));  if (len == 0) {    DBG(("%p no buf avail %u %u %u %p %p", tpcb, tpcb->acked, tpcb->snd_buf,         tpcb->snd_queuelen, tpcb->unsent, tpcb->unacked));    tcp_output(tpcb);    return 0;  }  err_t err = tcp_write(tpcb, data, len, TCP_WRITE_FLAG_COPY);  tcp_output(tpcb);  DBG(("%p tcp_write %u = %d", tpcb, len, err));  if (err != ERR_OK) {    /*     * We ignore ERR_MEM because memory will be freed up when the data is sent     * and we'll retry.     */    return err == ERR_MEM ? 0 : -1;  }  return len;}

//*****************************************************************************//// Send a request to the server//// /param pcRequest request to be sent// /param ui32Size length of the request to be sent. this is usually the size// of the request minus the termination character//// This function will send the request to the connected server//// /return the lwIP error code.////*****************************************************************************err_tEthClientSend(char *pcRequest, uint32_t ui32Size){    err_t eError;    eError = tcp_write(g_sEnet.psTCP, pcRequest, ui32Size,                       TCP_WRITE_FLAG_COPY);    //    //  Write data for sending (but does not send it immediately).    //    if(eError == ERR_OK)    {        //        // Find out what we can send and send it        //        tcp_output(g_sEnet.psTCP);    }    return(eError);}

static err_t sent(void *arg, struct tcp_pcb *tpcb, u16_t len){    struct iperf_state *is = (struct iperf_state *) arg;    is->sent_bytes += len;    if (is->amount > 0 && is->sent_bytes > is->amount) {        finish_send(is, tpcb);        return ERR_OK;    } else if (is->amount < 0 && (rte_get_timer_cycles()-is->send_start_ticks) > -is->amount) {        finish_send(is, tpcb);        return ERR_OK;    }    int space;    while ((space = tcp_sndbuf(tpcb)) >= sizeof(send_data)) {        tcp_write(tpcb, send_data, sizeof(send_data), 0);    }    return ERR_OK;}

/* * /brief This method should be called when a trace should be dumped on the network. */static void bfscope_trace_dump_network(void){    assert(bfscope_client != NULL);    assert(trace_length > 0);    printf("bfscope: sending %lu bytes to network.../n", trace_length);    /* Send length field */    char tmpbuf[10];    int len;    len = snprintf(tmpbuf, 9, "%08ld", trace_length);    tcp_write(bfscope_client, tmpbuf, 8, TCP_WRITE_FLAG_COPY);    /* Start to send the trace */    timestamp_start = rdtsc();    trace_sent = 0;    bfscope_trace_send(bfscope_client);    tcp_output(bfscope_client);}

/**  * read - the function will write bytes to the file  *                      * @param fd    the file handle  * @param buf   the sending buffer point  * @param count the maximum bytes to be sent  *  * @return the result  */ssize_t _write(int fd, const void *buf, size_t count){    struct socket *socket = (struct socket *)fd;    ssize_t size = -1;       if (SOCK_STREAM == socket->type)    {        size = tcp_write(socket->pcb, buf, count, TCP_WRITE_FLAG_COPY);    }    else if (SOCK_PACKET == socket->type)    {        struct pbuf *pbuf = pbuf_alloc(PBUF_RAW, count, PBUF_POOL);                if ((pbuf = ippkg_pack((os_u8 *)buf, count)) == NULL)            return -1;                      size = udp_send(socket->pcb, pbuf);    }      return size;}

int do_http_post(struct tcp_pcb* pcb, char* req, int rlen){	int BUFSIZE = 1024;	unsigned char buf[BUFSIZE];	int len, n;	char* p;	if (is_cmd_led(req)) {		n = toggle_leds();		len = generate_http_header((char*)buf, "js", 1);		p = (char*)buf + len;		*p++ = n ? '1':'0';		*p = 0;		len++;		xil_printf("http POST: ledstatus: %x/r/n", n);	} else if (is_cmd_switch(req)) {		unsigned s = get_switch_state();		int n_switches = 4;		xil_printf("http POST: switch state: %x/r/n", s);		len = generate_http_header((char*)buf, "js", n_switches);		p = (char*)buf + len;		for (n=0; n<n_switches; n++, p++) {			*p = '0' + (s & 0x1);			s >>= 1;		}		*p = 0;		len += n_switches;	}	if (tcp_write(pcb, buf, len, 1) != ERR_OK) {		xil_printf("error writing http POST response to socket/r/n");		xil_printf("http header = %s/r/n", buf);		return -1;	}	return 0;}

/** * Function: recvRemotePacket * Description: 当客户端收到服务器发送的数据时调用的回调函数 * @param arg 回调时传递回来的参数 * @param tpcb 当前连接的PCB * @param p  存放服务器发送过来的数据 * @param err 回调时传递回来的错误码 * @return err_t 类型的状态码**/err_t recvRemotePacket(void *arg, struct tcp_pcb *tpcb,struct pbuf *p, err_t err) {    struct pbuf *temp;    char *data;    err_t error_status;    int loc = 0;    if ((err != ERR_OK) || (p == NULL)) {        if(p != NULL) {            tcp_recved(tpcb, p->tot_len);            pbuf_free(p);        }        return ERR_OK;    }    if(p == NULL) {        printf("recv data is empty/n/r");    } else {        data = (char*)malloc(p->tot_len);        memset(data,0,p->tot_len);        memset(data,0,p->tot_len);        for(temp = p; temp ; temp = temp->next) {            memcpy(&data[loc],temp->payload,temp->len);            loc += temp->len;        }    }    tcp_recved(tpcb, p->tot_len);    if(p != NULL) {        pbuf_free(p);    }    error_status = tcp_write(tpcb,data,p->len,1);    if(error_status != ERR_OK) { //发送数据失败        printf("data send failed/n/r");        return ERR_MEM;    }	tcp_output(tpcb);    free(data);    data = NULL;}

static int chargen_worker(void *socket){    uint64_t count = 0;    tcp_socket_t *s = socket;/* enough buffer to hold an entire defacto chargen sequences */#define CHARGEN_BUFSIZE (0x5f * 0x5f) // 9025 bytes    uint8_t *buf = malloc(CHARGEN_BUFSIZE);    if (!buf)        return -1;    /* generate the sequence */    uint8_t c = '!';    for (size_t i = 0; i < CHARGEN_BUFSIZE; i++) {        buf[i] = c++;        if (c == 0x7f)            c = ' ';    }    lk_time_t t = current_time();    for (;;) {        ssize_t ret = tcp_write(s, buf, CHARGEN_BUFSIZE);        //TRACEF("tcp_write returns %d/n", ret);        if (ret < 0)            break;        count += ret;    }    t = current_time() - t;    TRACEF("chargen worker exiting, wrote %llu bytes in %u msecs (%llu bytes/sec)/n",        count, (uint32_t)t, count * 1000 / t);    free(buf);    tcp_close(s);    return 0;}

/* * /brief Send the next chunk of trace data down given TCP connection */static void bfscope_trace_send(struct tcp_pcb *tpcb){    char *bufptr;    int len;    //DEBUG("tcp_sndbuf=%d/n", tcp_sndbuf(tpcb));    bufptr = trace_buf + trace_sent;    len = trace_length - trace_sent;    int more = 0;    if (len > tcp_sndbuf(tpcb)) {        len = tcp_sndbuf(tpcb);        more = 1;    }    /* Give the data to LWIP until it runs out of buffer space */    err_t lwip_err = tcp_write(tpcb, bufptr, len,                      TCP_WRITE_FLAG_COPY | (more ? TCP_WRITE_FLAG_MORE : 0));    //DEBUG("%d %ld+%d/n", r, trace_sent, len);    if (lwip_err == ERR_MEM) {        printf("bfscope: lwip: out of memory/n");        return;    }    trace_sent += len;    if (trace_sent >= trace_length) {        /* No more events */        uint64_t timestamp_stop = rdtsc();        DEBUG("bfscope: done (%lu bytes) in %ld cycles/n",               trace_sent, timestamp_stop - timestamp_start);        bfscope_trace_dump_finished();    }}

intecho_client_send (void){	err_t err;	struct tcp_pcb *pcb = echo_client_pcb;	int buflen;	if (!echo_client_pcb) {		printd ("No connection./n");		return -1;	} else {		printd ("Connection found./n");	}	buflen = tcp_sndbuf (pcb);	if (buflen >= strlen (send_buf)) {		printd ("Space available: %d/n", buflen);		err = tcp_write (pcb, send_buf, strlen (send_buf),				 TCP_WRITE_FLAG_COPY);		if (err == ERR_OK) {			printd ("Enqueue succeeded./n");			err = tcp_output (pcb);			if (err == ERR_OK) {				printd ("Send succeeded./n");			} else {				printd ("Send failed./n");				return -2;			}		} else {			printd ("Enqueue failed./n");			return -3;		}	} else {		printd ("Space unavailable: %d/n", buflen);		return -4;	}	return 0;}

static int ps_send_deferred_acks(struct tcp_pcb *pcb) {	int num = (ps_deferred_ack_produce + PS_DEFERRED_ACK_MAX	           - ps_deferred_ack_consume) % PS_DEFERRED_ACK_MAX;	if (num) {		outputf("%d deferred acks/n", num);	}	int count = 0;	int consume = ps_deferred_ack_consume;	err_t err = 0;	while (consume != ps_deferred_ack_produce) {		struct dac_response response;		response.response = ps_deferred_ack_queue[consume].resp;		response.command = ps_deferred_ack_queue[consume].cmd;		fill_status(&response.dac_status);		err = tcp_write(pcb, &response, sizeof(response),			TCP_WRITE_FLAG_COPY);		if (err < 0)			break;		count++;		consume = (consume + 1) % PS_DEFERRED_ACK_MAX;	}	ps_deferred_ack_consume = consume;	if (err == ERR_MEM)		err = 0;	if (num)		outputf("sent %d deferred acks, err %d", count, err);	return err;}

//服务器连接成功后将要调用的函数err_t tcp_server_accept(void *arg, struct tcp_pcb *newpcb, err_t err){		err_t ret_err;		struct tcp_server_state* ts;			  ts = mem_malloc(sizeof(struct tcp_server_state));	 //申请内存		if(ts!=NULL){				ts->state = ES_RECEIVED;							//可以接收数据了			  lwip_flag |= LWIP_CONNECTED;				//已经连接上了			  tcp_write(newpcb,respond,strlen(respond),1);  //回应信息							tcp_arg(newpcb, ts);  				//将程序的协议控制块的状态传递给多有的回调函数				tcp_recv(newpcb, tcp_server_recv);	//指定连接接收到新的数据之后将要调用的回调函数				tcp_err(newpcb, tcp_server_error);	//指定连接出错将要调用的函数				tcp_poll(newpcb, tcp_server_poll, 0); //指定轮询时将要调用的回调函数				ret_err = ERR_OK;		}else{				ret_err = ERR_MEM;		}		return ret_err;	}

// Sends the next chunk of data.static voidsend_data(struct tcp_pcb *pcb, struct http_state *hs){    err_t err;    u16_t len;        CYG_TEST_INFO("Sending data");    // We cannot send more data than space available in the send buffer    len = tcp_sndbuf(pcb) < hs->left ? tcp_sndbuf(pcb) : hs->left;        do {        err = tcp_write(pcb, hs->file, len, 0);        if (err == ERR_MEM) {            len /= 2;        }    } while (err == ERR_MEM && len > 1);    if (err == ERR_OK) {        hs->file += len;        hs->left -= len;    }}

/**  * @brief  reply to the all user who is aliving.   * @param            *pcb: the poiter of the pcb struct.            *Cmd: the pointer of the 24byte date.   * @retval None  */static void Pcb_Write_ALL(const void *data){   int try_times = 0;   int t = 0;    	  for(t = 0; t < 11; t++)  {    if(pad_info[t].user == TRUE && pad_info[t].pad_living>0) 	{	  if(pad_info[t].socket != sever_pcb)	  {	    while(tcp_write(pad_info[t].socket, data, 24, 1)!= ERR_OK && try_times < 500)	    {		    try_times++;	  	  vTaskDelay(1);	    }	  }    }  }    Pcb_Write_Sever(data);}

size_t EthernetClient::write(const uint8_t *buf, size_t size) {	uint32_t i = 0, inc = 0;	boolean stuffed_buffer = false;	struct tcp_pcb * cpcb = (tcp_pcb*)cs->cpcb; /* cs->cpcb may change to NULL during interrupt servicing */	if (!cpcb)		return 0;	// Attempt to write in 1024-byte increments.	while (i < size) {		inc = (size - i) < 1024 ? size - i : 1024;		err_t err = tcp_write(cpcb, buf + i, inc, TCP_WRITE_FLAG_COPY);		if (err != ERR_MEM) {			// Keep enqueueing the lwIP buffer until it's full...			i += inc;			stuffed_buffer = false;		} else {			if (!stuffed_buffer) {				// Buffer full; force output				if (cs->mode)					tcp_output(cpcb);				stuffed_buffer = true;			} else {				delay(1); // else wait a little bit for lwIP to flush its buffers			}		}	}	// flush any remaining queue contents	if (!stuffed_buffer) {		if (cs->mode)			tcp_output(cpcb);	}	return size;}

/** * This function is called when data has been acknowledged by the * remote endpoint. */static err_t on_tcp_sent(void *arg_p,                         struct tcp_pcb *pcb_p,                         u16_t len){    struct socket_t *socket_p = arg_p;    struct send_to_args_t *args_p;    size_t size;    if (socket_p->output.cb.state == STATE_SENDTO) {        args_p = socket_p->output.cb.args_p;        size = MIN(args_p->extra.left,                   tcp_sndbuf(((struct tcp_pcb *)socket_p->pcb_p)));        if (tcp_write(socket_p->pcb_p,                      args_p->buf_p,                      size,                      TCP_WRITE_FLAG_COPY) == ERR_OK) {            args_p->buf_p += size;            args_p->extra.left -= size;            /* Resume if all data has been written. */            if (args_p->extra.left == 0) {                tcp_output(socket_p->pcb_p);                socket_p->output.cb.state = STATE_IDLE;                fs_counter_increment(&module.tcp_tx_bytes, args_p->size);                resume_thrd(socket_p->output.cb.thrd_p, args_p->size);            } else {                socket_p->output.cb.state = STATE_SENDTO;            }        } else {            resume_thrd(socket_p->output.cb.thrd_p, 0);        }    }    return (ERR_OK);}

int /*if < 0 : NetTcpSocketErr*/ LwipNetTcpSocket::send(const char* buf, int len){  if( !m_pPcb ) //Pcb doesn't exist (anymore)    return NETTCPSOCKET_MEM;  int outLen = MIN( len, tcp_sndbuf( (tcp_pcb*) m_pPcb) );   //tcp_sndbuf() returns the number of bytes available in the output queue, so never go above it  err_t err = tcp_write( (tcp_pcb*) m_pPcb, (void*) buf, outLen, TCP_WRITE_FLAG_COPY );  //Flags are TCP_WRITE_FLAG_COPY & TCP_WRITE_FLAG_MORE (see tcp_out.c) :  //If TCP_WRITE_FLAG_MORE is not set ask client to push buffered data to app  if(err)  {    switch( err )    {    case ERR_CONN:      return (int) NETTCPSOCKET_SETUP; //Not connected properly    case ERR_ARG:      return (int) NETTCPSOCKET_SETUP; //Wrong args ! (like buf pointing to NULL)    case ERR_MEM:    default:      return (int) NETTCPSOCKET_MEM; //Not enough memory    }  }  return outLen;}

static err_techo_recv_callback(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err){    /* do not read the packet if we are not in ESTABLISHED state */    if (!p) {        tcp_close(tpcb);        tcp_recv(tpcb, NULL);        return ERR_OK;    }    /* indicate that the packet has been received */    tcp_recved(tpcb, p->len);    /* echo back the payload */    /* in this case, we assume that the payload is < TCP_SND_BUF */    if (tcp_sndbuf(tpcb) > p->len) {        err = tcp_write(tpcb, p->payload, p->len, 1);    }    /* free the received pbuf */    pbuf_free(p);    return ERR_OK;}

static void proc_rx_data(struct tcp_pcb * pcb, struct telnetio_dev *teldev, struct pbuf *p){	struct pbuf *q;	unsigned char *c;	int num, i;	TELNETD_DEBUG(("line:%d, %s()/n", __LINE__, __FUNCTION__));	rt_sem_take(teldev->rx_rb_buf.rw_sem, RT_WAITING_FOREVER);	for(q=p; NULL!=q; q=q->next) {		c = q->payload;		for(i=0; i<q->len; i++, c++)			proc_rx_byte(pcb, teldev, *c);	}	rt_sem_release(teldev->rx_rb_buf.rw_sem);	num = teldev->iac_index;	if (0 != num) {		tcp_write(pcb, teldev->iac_buf, num, TCP_WRITE_FLAG_COPY);		teldev->iac_index = 0;	}	return;}

size_t device_write(const __ptr_t buf, size_t n, struct gn_statemachine *state){	switch (state->device.type) {	case GN_CT_DKU2:	case GN_CT_Serial:	case GN_CT_Infrared:		return serial_write(state->device.fd, buf, n, state);	case GN_CT_Irda:		return irda_write(state->device.fd, buf, n, state);	case GN_CT_Bluetooth:		return bluetooth_write(state->device.fd, buf, n, state);	case GN_CT_Tekram:		return tekram_write(state->device.fd, buf, n, state);	case GN_CT_TCP:		return tcp_write(state->device.fd, buf, n, state);	case GN_CT_DKU2LIBUSB:		return fbusdku2usb_write(buf, n, state);	case GN_CT_SOCKETPHONET:		return socketphonet_write(state->device.fd, buf, n, state);	default:		break;	}	return 0;}

int TcpConnection::write(const char* data, int len, uint8_t apiflags /* = TCP_WRITE_FLAG_COPY*/){   //int original = len;   u16_t available = getAvailableWriteSize();   if (available < len)   {	   if (available == 0)		   return -1; // No memory	   else		   len = available;   }   err_t err = tcp_write(tcp, data, len, apiflags);   if (err == ERR_OK)   {		debugf("TCP connection send: %d ", len);		return len;   } else {		debugf("TCP connection failed with err %d ", err);		return -1;   }}

/** * See if more data needs to be written from a previous call to netconn_write. * Called initially from do_write. If the first call can't send all data * (because of low memory or empty send-buffer), this function is called again * from sent_tcp() or poll_tcp() to send more data. If all data is sent, the * blocking application thread (waiting in netconn_write) is released. * * @param conn netconn (that is currently in state NETCONN_WRITE) to process * @return ERR_OK *         ERR_MEM if LWIP_TCPIP_CORE_LOCKING=1 and sending hasn't yet finished */static err_tdo_writemore(struct netconn *conn){    err_t err;    void *dataptr;    u16_t len, available;    u8_t write_finished = 0;    size_t diff;    u8_t dontblock = netconn_is_nonblocking(conn) ||                     (conn->current_msg->msg.w.apiflags & NETCONN_DONTBLOCK);    u8_t apiflags = conn->current_msg->msg.w.apiflags;    LWIP_ASSERT("conn != NULL", conn != NULL);    LWIP_ASSERT("conn->state == NETCONN_WRITE", (conn->state == NETCONN_WRITE));    LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);    LWIP_ASSERT("conn->pcb.tcp != NULL", conn->pcb.tcp != NULL);    LWIP_ASSERT("conn->write_offset < conn->current_msg->msg.w.len",                conn->write_offset < conn->current_msg->msg.w.len);#if LWIP_SO_SNDTIMEO    if ((conn->send_timeout != 0) &&            ((s32_t)(sys_now() - conn->current_msg->msg.w.time_started) >= conn->send_timeout)) {        write_finished = 1;        if (conn->write_offset == 0) {            /* nothing has been written */            err = ERR_WOULDBLOCK;            conn->current_msg->msg.w.len = 0;        } else {            /* partial write */            err = ERR_OK;            conn->current_msg->msg.w.len = conn->write_offset;        }    } else#endif /* LWIP_SO_SNDTIMEO */    {        dataptr = (u8_t*)conn->current_msg->msg.w.dataptr + conn->write_offset;        diff = conn->current_msg->msg.w.len - conn->write_offset;        if (diff > 0xffffUL) { /* max_u16_t */            len = 0xffff;#if LWIP_TCPIP_CORE_LOCKING            conn->flags |= NETCONN_FLAG_WRITE_DELAYED;#endif            apiflags |= TCP_WRITE_FLAG_MORE;        } else {            len = (u16_t)diff;        }        available = tcp_sndbuf(conn->pcb.tcp);        if (available < len) {            /* don't try to write more than sendbuf */            len = available;            if (dontblock) {                if (!len) {                    err = ERR_WOULDBLOCK;                    goto err_mem;                }            } else {#if LWIP_TCPIP_CORE_LOCKING                conn->flags |= NETCONN_FLAG_WRITE_DELAYED;#endif                apiflags |= TCP_WRITE_FLAG_MORE;            }        }        LWIP_ASSERT("do_writemore: invalid length!", ((conn->write_offset + len) <= conn->current_msg->msg.w.len));        err = tcp_write(conn->pcb.tcp, dataptr, len, apiflags);        /* if OK or memory error, check available space */        if ((err == ERR_OK) || (err == ERR_MEM)) {err_mem:            if (dontblock && (len < conn->current_msg->msg.w.len)) {                /* non-blocking write did not write everything: mark the pcb non-writable                   and let poll_tcp check writable space to mark the pcb writable again */                API_EVENT(conn, NETCONN_EVT_SENDMINUS, len);                conn->flags |= NETCONN_FLAG_CHECK_WRITESPACE;            } else if ((tcp_sndbuf(conn->pcb.tcp) <= TCP_SNDLOWAT) ||                       (tcp_sndqueuelen(conn->pcb.tcp) >= TCP_SNDQUEUELOWAT)) {                /* The queued byte- or pbuf-count exceeds the configured low-water limit,                   let select mark this pcb as non-writable. */                API_EVENT(conn, NETCONN_EVT_SENDMINUS, len);            }        }        if (err == ERR_OK) {            conn->write_offset += len;            if ((conn->write_offset == conn->current_msg->msg.w.len) || dontblock) {                /* return sent length */                conn->current_msg->msg.w.len = conn->write_offset;                /* everything was written */                write_finished = 1;                conn->write_offset = 0;            }//.........这里部分代码省略.........

void zmq::stream_engine_t::out_event (){    zmq_assert (!io_error);    //  If write buffer is empty, try to read new data from the encoder.    if (!outsize) {        //  Even when we stop polling as soon as there is no        //  data to send, the poller may invoke out_event one        //  more time due to 'speculative write' optimisation.        if (unlikely (encoder == NULL)) {            zmq_assert (handshaking);            return;        }        outpos = NULL;        outsize = encoder->encode (&outpos, 0);        while (outsize < out_batch_size) {            if ((this->*next_msg) (&tx_msg) == -1)                break;            encoder->load_msg (&tx_msg);            unsigned char *bufptr = outpos + outsize;            size_t n = encoder->encode (&bufptr, out_batch_size - outsize);            zmq_assert (n > 0);            if (outpos == NULL)                outpos = bufptr;            outsize += n;        }        //  If there is no data to send, stop polling for output.        if (outsize == 0) {            output_stopped = true;            reset_pollout (handle);            return;        }    }    //  If there are any data to write in write buffer, write as much as    //  possible to the socket. Note that amount of data to write can be    //  arbitrarily large. However, we assume that underlying TCP layer has    //  limited transmission buffer and thus the actual number of bytes    //  written should be reasonably modest.    const int nbytes = tcp_write (s, outpos, outsize);    //  IO error has occurred. We stop waiting for output events.    //  The engine is not terminated until we detect input error;    //  this is necessary to prevent losing incoming messages.    if (nbytes == -1) {        reset_pollout (handle);        return;    }    outpos += nbytes;    outsize -= nbytes;    //  If we are still handshaking and there are no data    //  to send, stop polling for output.    if (unlikely (handshaking))        if (outsize == 0)            reset_pollout (handle);}

int transfer_data() {    uint16_t data[1900];    tcp_write(pcb, data, sizeof(data)/ sizeof(*data),0); // send some data    return 0;}

// lwip calls this function when the connection is establishedstatic err_t hc_connected(void *arg, struct tcp_pcb *pcb, err_t err){    struct hc_state *hcstate = arg;    char  * headers;     // error?    if(err != ERR_OK)    {        hc_clearpcb(pcb);         // Call return function        (*hcstate->ReturnPage)(hcstate->Num, GEN_ERROR, NULL, 0);         // Free wc hcstate        free(hcstate->RecvData);        free(hcstate);         return(ERR_OK);    }     // Define Headers    if(hcstate->PostVars == NULL)    {	        // GET headers (without page)(+ /0) = 19        headers = malloc(19 + strlen(hcstate->Page));        sprintf(headers,"GET /%s HTTP/1.0/r/n/r/n", hcstate->Page);    }    else    {        // POST headers (without PostVars or Page)(+ /0) = 91        // Content-length: %d <== 						   ??? (max 10)        headers = malloc(91 + strlen(hcstate->PostVars) + strlen(hcstate->Page) + 10);        sprintf(headers, "POST /%s HTTP/1.0/r/nContent-type: application/x-www-form-urlencoded/r/nContent-length: %d/r/n/r/n%s/r/n/r/n", hcstate->Page, strlen(hcstate->PostVars), hcstate->PostVars);    }     // Check if we are nut running out of memory    if(headers == NULL)    {        hc_clearpcb(pcb);         // Call return function        (*hcstate->ReturnPage)(hcstate->Num, OUT_MEM, NULL, 0);         // Free wc hcstate        free(hcstate->RecvData);        free(hcstate);         return(ERR_OK);    }      // Send data    tcp_write(pcb, headers, strlen(headers), 1);    tcp_output(pcb);     // remove headers    free(headers);    free(hcstate->PostVars);			// postvars are send, so we don't need them anymore    free(hcstate->Page);		    	        // page is requested, so we don't need it anymore     return(ERR_OK);}

int net_send(spdid_t spdid, net_connection_t nc, void *data, int sz){	struct intern_connection *ic;	u16_t tid = cos_get_thd_id();	int ret = sz;//	if (!cos_argreg_buff_intern(data, sz)) return -EFAULT;	if (!net_conn_valid(nc)) return -EINVAL;	if (sz > MAX_SEND) return -EMSGSIZE;//	NET_LOCK_TAKE();	ic = net_conn_get_internal(nc);	if (NULL == ic) {		ret = -EINVAL;		goto err;	}	if (tid != ic->tid) {		ret = -EPERM;		goto err;	}	switch (ic->conn_type) {	case UDP:	{		struct udp_pcb *up;		struct pbuf *p;		/* There's no blocking in the UDP case, so this is simple */		up = ic->conn.up;		p = pbuf_alloc(PBUF_TRANSPORT, sz, PBUF_ROM);		if (NULL == p) {			ret = -ENOMEM;			goto err;		}		p->payload = data;		if (ERR_OK != udp_send(up, p)) {			pbuf_free(p);			/* IP/port must not be set */			ret = -ENOTCONN;			goto err;		}		pbuf_free(p);		break;	}	case TCP:	{		struct tcp_pcb *tp;#define TCP_SEND_COPY#ifdef TCP_SEND_COPY		void *d;		struct packet_queue *pq;#endif		tp = ic->conn.tp;		if (tcp_sndbuf(tp) < sz) { 			ret = 0;			break;		}#ifdef TCP_SEND_COPY		pq = malloc(sizeof(struct packet_queue) + sz);		if (unlikely(NULL == pq)) {			ret = -ENOMEM;			goto err;		}#ifdef TEST_TIMING		pq->ts_start = timing_record(APP_PROC, ic->ts_start);#endif		pq->headers = NULL;		d = net_packet_data(pq);		memcpy(d, data, sz);		if (ERR_OK != (ret = tcp_write(tp, d, sz, 0))) {#else		if (ERR_OK != (ret = tcp_write(tp, data, sz, TCP_WRITE_FLAG_COPY))) {#endif			free(pq);			printc("tcp_write returned %d (sz %d, tcp_sndbuf %d, ERR_MEM: %d)", 			       ret, sz, tcp_sndbuf(tp), ERR_MEM);			BUG();		}		/* No implementation of nagle's algorithm yet.  Send		 * out the packet immediately if possible. */		if (ERR_OK != (ret = tcp_output(tp))) {			printc("tcp_output returned %d, ERR_MEM: %d", ret, ERR_MEM);			BUG();		}		ret = sz;		break;	}	case TCP_CLOSED:		ret = -EPIPE;		break;	default:		BUG();	}err://	NET_LOCK_RELEASE();	return ret;}//.........这里部分代码省略.........