int vicc_present(struct vicc_ctx *ctx) { unsigned char *atr = NULL; if (!ctx) return 0; if (ctx->client_sock < 0) { if (ctx->server_sock) { /* server mode, try to accept a client */ ctx->client_sock = waitforclient(ctx->server_sock, 0, 0); if (!ctx->client_sock) { ctx->client_sock = -1; } } else { /* client mode, try to connect (again) */ ctx->client_sock = connectsock(ctx->hostname, ctx->port); } } if (ctx->client_sock < 0) /* not connected */ return 0; /* get the atr to check if the card is still alive */ if (vicc_getatr(ctx, &atr) <= 0) return 0; free(atr); return 1; }
/*------------------------------------------------------------------------ * connectUDP - connect to a specified UDP service on a specified host *------------------------------------------------------------------------ */ SOCKET connectUDP(const char *host, const char *service) { /* * Arguments: * host - name of host to which connection is desired * service - service associated with the desired port */ return connectsock(host, service, "udp"); }
TCPdaytime(const char *host, char *type) { char buf[LINELEN+1]; /* buffer for one line of text */ int s, n; /* socket, read count */ s = connectsock(host, type); while( (n = read(s, buf, LINELEN)) > 0) { buf[n] = '\0'; /* ensure null-terminated */ (void) fputs( buf, stdout ); } }
/*------------------------------------------------------------------------ * connectTCP - connect to a specified TCP service on a specified host *------------------------------------------------------------------------ */ int connectTCP(const char *host, const char *service ) /* * Arguments: * host - name of host to which connection is desired * service - service associated with the desired port */ { return connectsock( host, service, "tcp"); }
/*------------------------------------------------------------------------ * TCPecho - send input to ECHO service on specified host and print reply *------------------------------------------------------------------------ */ int TCPecho(const char *host, const char *portnum) { char buf[LINELEN+1]; /* buffer for one line of text */ int s, n; /* socket descriptor, read count*/ int outchars, inchars; /* characters sent and received */ SSL_CTX *ctx; SSL *ssl; X509 *server_cert; EVP_PKEY *pkey; SSL_library_init(); SSL_load_error_strings(); const SSL_METHOD *meth = SSLv3_method(); ctx = SSL_CTX_new(meth); // Consider verifying the client (or server i guess) if (!SSL_CTX_load_verify_locations(ctx, RSA_CLIENT_CA_CERT, NULL)) { fprintf(stderr, "SSL load verify locations\n"); ERR_print_errors_fp(stderr); exit(1); } SSL_CTX_set_verify(ctx,SSL_VERIFY_PEER,NULL); SSL_CTX_set_verify_depth(ctx,1); ssl = SSL_new(ctx); s = connectsock(host, portnum); SSL_set_fd(ssl, s); SSL_connect(ssl); printf("SSL CONNECTION USING %s\n", SSL_get_cipher(ssl)); while (fgets(buf, sizeof(buf), stdin)) { buf[LINELEN] = '\0'; /* insure line null-terminated */ outchars = strlen(buf); (void) SSL_write(ssl, buf, outchars); /* read it back */ for (inchars = 0; inchars < outchars; inchars+=n ) { n = SSL_read(ssl, &buf[inchars], outchars - inchars); if (n < 0) errexit("socket read failed: %s\n", strerror(errno)); } fputs(buf, stdout); } }
struct vicc_ctx * vicc_init(const char *hostname, unsigned short port) { struct vicc_ctx *r = NULL; struct vicc_ctx *ctx = malloc(sizeof *ctx); if (!ctx) { goto err; } ctx->hostname = NULL; ctx->io_lock = NULL; ctx->server_sock = -1; ctx->client_sock = -1; ctx->port = port; #ifdef _WIN32 WSADATA wsaData; WSAStartup(MAKEWORD(2, 2), &wsaData); #endif ctx->io_lock = create_lock(); if (!ctx->io_lock) { goto err; } if (hostname) { ctx->hostname = strdup(hostname); if (!ctx->hostname) { goto err; } ctx->client_sock = connectsock(hostname, port); } else { ctx->server_sock = opensock(port); if (ctx->server_sock < 0) { goto err; } } r = ctx; err: if (!r) { vicc_exit(ctx); } return r; }
/*------------------------------------------------------------------------ * TCPecho - send input to ECHO service on specified host and print reply *------------------------------------------------------------------------ */ int TCPecho(const char *host, const char *portnum, SSL_CTX *ctx) { char buf[LINELEN]; /* buffer for one line of text */ memset(buf, '\0', sizeof(buf)); int s; /* socket descriptor, read count*/ SSL *ssl; s = connectsock(host, portnum); /* Create an SSL structure and authenticate the server certificate */ ssl = authenticate_server(s, ctx); while (fgets(buf, sizeof(buf), stdin)) { if(SSL_write(ssl, buf, strlen(buf)) <= 0) { errexit("SSL_write failed.\n"); } memset(buf, '\0', sizeof(buf)); if(SSL_read(ssl, buf, sizeof(buf)) <= 0) { errexit("SSL_read failed.\n"); } fputs(buf, stdout); memset(buf, '\0', sizeof(buf)); } SSL_shutdown(ssl); (void) close(s); SSL_free(ssl); SSL_CTX_free(ctx); return EXIT_SUCCESS; }
int vicc_connect(struct vicc_ctx *ctx, long secs, long usecs) { if (!ctx) return 0; if (ctx->client_sock == INVALID_SOCKET) { if (ctx->server_sock) { /* server mode, try to accept a client */ ctx->client_sock = waitforclient(ctx->server_sock, secs, usecs); if (!ctx->client_sock) { ctx->client_sock = INVALID_SOCKET; } } else { /* client mode, try to connect (again) */ ctx->client_sock = connectsock(ctx->hostname, ctx->port); } } if (ctx->client_sock == INVALID_SOCKET) /* not connected */ return 0; else return 1; }
int connectTCP(const char* host, const char* service, const char* transport) { return connectsock(host, service, "tcp"); }
int main(int argc, char *argv[]) { fd_set rfds; struct timeval tv; int retval; int i1; char buffer[4095]; struct sockaddr_in fsin; int alen; peer_t *p; int s; struct sockaddr_in address; if (argc < 3) { printf("Usage: %s <port> <remote server> <remote server port>\n", argv[0]); return 1; } NET_Init(); if ((s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { perror("socket"); return 1; } address.sin_family = AF_INET; address.sin_addr.s_addr = INADDR_ANY; address.sin_port = htons((unsigned short)atoi(argv[1])); if (bind (s, (void *)&address, sizeof(address)) == -1) perror("bind"); while(1) { FD_ZERO(&rfds); FD_SET(s, &rfds); i1 = s; for (p = peers; p; p = p->next) { FD_SET(p->s, &rfds); if (p->s >= i1) i1 = p->s + 1; } /* Wait up to two minutes. */ tv.tv_sec = 2; tv.tv_usec = 0; retval = select(i1, &rfds, (fd_set *)0, (fd_set *)0, &tv); if(retval > 0) { if(FD_ISSET(s, &rfds)) { alen = sizeof(fsin); i1 = recvfrom(s, buffer, 4096, 0, (struct sockaddr *) &fsin, &alen); if(i1 > 0) { for (p = peers; p; p = p->next) if (memcmp(&p->sin.sin_addr, &fsin.sin_addr, sizeof(p->sin.sin_addr)) == 0 && memcmp(&p->sin.sin_port, &fsin.sin_port, sizeof(p->sin.sin_port)) == 0) { send(p->s, buffer, i1, 0); time(&p->last); break; } if (p == NULL) { // new peer printf("peer %s:%d added", inet_ntoa(fsin.sin_addr), (int)ntohs(fsin.sin_port)); p = malloc(sizeof *p); p->sin = fsin; p->s = connectsock(argv[2], argv[3], "udp"); p->next = peers; peers = p; send(p->s, buffer, i1, 0); time(&p->last); } } } for (p = peers; p; p = p->next) if(FD_ISSET(p->s, &rfds)) { i1 = recv(p->s, buffer, 4096, 0); if(i1 > 0) { time(&p->last); sendto(s, buffer, i1, 0, (struct sockaddr *) &p->sin, sizeof(p->sin)); } } } else { peer_t *pp; pp = NULL; p = peers; while (p) { if (time(NULL) - p->last > 300) { if (!pp && !p->next) { printf("peer %s:%d removed (timeout)", inet_ntoa(p->sin.sin_addr), (int)ntohs(p->sin.sin_port)); free(p); p = pp = NULL; continue; } pp->next = p->next; printf ("peer %s:%d removed (timeout)", inet_ntoa(p->sin.sin_addr), (int)ntohs(p->sin.sin_port)); free(p); p = pp->next; } else { pp = p; p = p->next; } } } } }
//-------------------------------------------------------------------------------------------------------------------- int connectUDP( const char *host, const char* service ) { return connectsock( host, service, "udp" ); }
SOCKET connecttomaster(char *str) { char *tempch; SOCKET sock; char msg[100]; char ConnectStr[100]; /* Fix to handle multiple threads */ int tries; strcpy(ConnectStr, str); /* * BREAK UP THE connectstr INTO A HOSTNAME/HOST-IP AND A PORT NUMBER. */ if((tempch = strpbrk(ConnectStr,":")) == 0) { /* * INCORRECT FORMAT OF ConnectStr. CORRECT FORMAT IS * HOSTNAME:PORT OR HOST-IP:PORT */ D_PRINTF( "Incorrect format %s: use hostname:port or ip_addr:port\n", ConnectStr ); return(returnerr("Incorrect format %s: use host:port or ip_addr:port\n", ConnectStr)); } /* * ZERO OUT THE COLON SO WE HAVE TWO STRINGS, THE HOSTNAME AND THE PORT */ *tempch = '\0'; tempch++; /* loop here to connect to webmaster - TCP/IP allows no more than 5 * connection requests outstanding at once and thus the webmaster may * reject a connection if there are a lot of client processes */ #define MAXTRIES 30 #define TRYDELAY_SEC 1 for (tries = 0; tries < MAXTRIES; tries++) { sock = connectsock(ConnectStr,(NETPORT)atoi(tempch),"tcp"); if (!BADSOCKET(sock)) break; sleep(TRYDELAY_SEC); } if (BADSOCKET(sock)) { /* ERROR CONNECTING TO MASTER PROCESS */ return(returnerr("Could not connect to master process\n")); } /* * SIGNAL THE MASTER THAT WE ARE READY TO PROCEED. WHEN ALL * CHILD PROCESSES HAVE CONNECTED AND SENT THIS SIGNAL, * THE MASTER WILL ISSUE US A GO SIGNAL. */ if(NETWRITE(sock,READYSTR,READYSTRLEN) != READYSTRLEN) { return(returnerr("Error sending READY message to master")); } memset(msg,0,GOSTRLEN+1); if(NETREAD(sock,msg,GOSTRLEN) != GOSTRLEN) { D_PRINTF( "Error receiving GO message from master: %s\n", neterrstr() ); return(returnerr("Error receiving GO message from master\n")); } if(strncmp(GOSTR,msg,GOSTRLEN)) { /* * WE RECEIVED A MESSAGE OTHER THAN GO. PRINT IT OUT AND RETURN ERROR */ return(returnerr("Received non-GO message %s\n",msg)); } return(sock); } /* END connecttomaster() */
/* send HTTP Request and send back response */ int send_request(int client, const struct HTTP_Request req) { char buf[BUFSIZE]; int server; /* socket descriptor to server */ int len; int rv; printf("Processing request to %s\n", req.site); printf("'%s'\n", req.full_req); server = connectsock(req.site, req.port); /* Keep track of file descriptors */ fd_set set; FD_ZERO(&set); FD_SET(server, &set); FD_SET(client, &set); int smax = (client > server ? client : server) + 1; struct timeval timeout; timeout.tv_sec = 10; /* Forward response */ if (send(server, req.full_req, strlen(req.full_req), 0) < 0) { printf("Connection to site %s unavailable\n", req.site); return -1; } printf("Message forwarded to server\n"); while ((rv = select(smax, &set, NULL, NULL, NULL)) > 0) { printf("Message received: "); len = 0; /* Check client for requests */ if ((FD_ISSET(client, &set) > 0)) { printf("Client sent message\n"); /* Read input from client */ len = recv(client, &buf[len], (BUFSIZE-len), 0); buf[len-1] = '\0'; printf("'%d'\n", strlen(buf)); /* Forward to server*/ if (write(server, buf, len) < 0) { errexit("Failed write: %s\n", strerror(errno)); return -1; } printf("Message forwarded to server\n"); } /* Check server for requests */ if ((FD_ISSET(server, &set) > 0)) { printf("Server sent message\n"); /* Read input from server */ len = recv(server, &buf[len], (BUFSIZE-len), 0); buf[len-1] = '\0'; printf("'%d'\n", strlen(buf)); /* Forward to server*/ if (write(client, buf, len) < 0) { errexit("Failed write: %s\n", strerror(errno)); return -1; } printf("Message forwarded to client\n"); } } printf("Exiting function\n"); return 0; }
SOCKET postiveTCP_with_addr(struct sockaddr_in *remote_addr) { return connectsock( "localhost", "ftp", "tcp", remote_addr); }
/*------------------------------------------------------------------------ * connectTCP - connect to a specified TCP service on a specified host *------------------------------------------------------------------------ */ SOCKET postiveTCP(const char *host, const char *service ) { return connectsock( host, service, "tcp", NULL); }
SOCKET connectTCP(char *host, const char *service, int augment ) { return connectsock( host, service, "tcp", augment); }