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);
}
