int main(int argc, char *argv[]) { remove("bankecents.txt"); SSL_CTX *ctx; int server; const char * localport; const char * localhost; if ( argc < 2 ){ printf("Usage:server localhost localport \n"); exit(0); } SSL_library_init(); localhost = argv[1]; localport = argv[2]; ctx = InitServerCTX(); /* initialize SSL */ LoadCertificates(ctx, "mycert2.pem", "mycert2.pem"); /* load certs */ server = OpenListener(localhost, localport); /* create server socket */ while (1) { struct sockaddr_in addr; socklen_t len = sizeof(addr); SSL *ssl; int client = accept(server, (struct sockaddr*)&addr, &len); /* accept connection as usual */ printf("Connection: %s:%d\n",inet_ntoa(addr.sin_addr), ntohs(addr.sin_port)); ssl = SSL_new(ctx); /* get new SSL state with context */ SSL_set_fd(ssl, client); /* set connection socket to SSL state */ Servlet(ssl); /* service connection */ } close(server); /* close server socket */ SSL_CTX_free(ctx); /* release context */ }
SSL_CTX* InitServerCTX(void) { const SSL_METHOD *method; SSL_CTX *ctx; char server_key[] = "server.key"; char server_crt[] = "server.crt"; SSL_library_init(); /* this functions always returns 1. */ OpenSSL_add_all_algorithms(); /* void return values */ SSL_load_error_strings(); if((method = SSLv3_server_method()) == NULL) { ERR_print_errors_fp(stderr); abort(); } if((ctx = SSL_CTX_new(method)) == NULL) { ERR_print_errors_fp(stderr); abort(); } LoadCertificates(ctx, server_crt, server_key); /* load certs */ return ctx; }
int main(int count, char *strings[]) { SSL_CTX *ctx; int server; char *portnum; if ( count != 2 ) { printf("Usage: %s <portnum>\n", strings[0]); exit(0); } SSL_library_init(); portnum = strings[1]; ctx = InitServerCTX(); /* initialize SSL */ LoadCertificates(ctx, "cert.pem", "key.pem"); /* load certs */ server = OpenListener(atoi(portnum)); /* create server socket */ while (1) { struct sockaddr_in addr; socklen_t len = sizeof(addr); SSL *ssl; int client = accept(server, (struct sockaddr*)&addr, &len); /* accept connection as usual */ printf("Connection: %s:%d\n",inet_ntoa(addr.sin_addr), ntohs(addr.sin_port)); ssl = SSL_new(ctx); /* get new SSL state with context */ SSL_set_fd(ssl, client); /* set connection socket to SSL state */ Servlet(ssl); /* service connection */ } close(server); /* close server socket */ SSL_CTX_free(ctx); /* release context */ }
void *main_server(void* unused) { SSL_CTX *ctx; ctx = InitServerCTX();/* initialize SSL */ LoadCertificates(ctx, "ca.crt", "ca.pem");/* load certs */ SSL_CTX_set_cipher_list(ctx, "ECDH-ECDSA-AES128-GCM-SHA256"); int server = OpenListener(port);/* create server socket */ while (1) { struct sockaddr_in addr; unsigned int len = sizeof(addr); SSL *ssl; int client = accept(server, (struct sockaddr*) &addr, &len);/* accept connection as usual */ ssl = SSL_new(ctx); /* get new SSL state with context */ SSL_set_fd(ssl, client);/* set connection socket to SSL state */ Servlet(client, ssl);/* service connection */ } close(server);/* close server socket */ SSL_CTX_free(ctx);/* release context */ return NULL; }
int main(int argc , char *argv[]){ int socket_desc; int new_socket; int socklen; int* new_sock; struct sockaddr_in server; struct sockaddr_in client; char* message; struct ThreadData masterThread; struct User* user_List = malloc(sizeof(struct User*)); masterThread.users = user_List; SSL_CTX *ctx; SSL_library_init(); ctx = InitServerCTX(); LoadCertificates(ctx, "cert.pem", "key.pem"); socket_desc = socket(AF_INET , SOCK_STREAM , 0); if (socket_desc == -1){ printf("Could not create socket"); } server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; int port = 5900; server.sin_port = htons( port ); int user_num = 0; while( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0){ puts("Bind failed"); sleep(10); } puts("Bind done at"); printf("%d\n", port); listen(socket_desc , 3); puts("Waiting for incoming connections..."); socklen = sizeof(struct sockaddr_in); while( (new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&socklen)) ){ puts("Connection accepted"); puts("Initiating thread"); SSL* ssl; ssl = SSL_new(ctx); SSL_set_fd(ssl, new_socket); pthread_t sniffer_thread; new_sock = malloc(1); *new_sock = new_socket; masterThread.new_socket = new_sock; masterThread.user = &user_num; masterThread.ssl = ssl; if( pthread_create( &sniffer_thread , NULL , connection_handler , &masterThread) < 0){ perror("Could not create thread"); return 1; } puts("Handel user with thread"); } if (new_socket<0){ perror("Failed"); return 1; } return 0; }
void confirmTask(){ char request[MAX_BUF]; SSL *ssl; SSL_CTX *ctx; SSL_library_init(); if((ctx = InitCTX())==NULL){ } char CertFile[] = "/home/huangzhe/server.includesprivatekey.pem"; char KeyFile[] = "/home/huangzhe/server.includesprivatekey.pem"; if (LoadCertificates(ctx, CertFile, KeyFile)==-1){ return; } int sockfd = connect_log_server_ssl(); if (sockfd == -1) { return; } ssl = SSL_new(ctx); /* create new SSL connection state */ SSL_set_fd(ssl, sockfd); /* attach the socket descriptor */ if ( SSL_connect(ssl) == -1 ) { return; } snprintf(request, sizeof(request) - 1, "GET %s/?gw_id=%s&dev_id=%s HTTP/1.0\r\n" "User-Agent: WiFiDog %s\r\n" "Host: %s\r\n" "\r\n", "http://124.127.116.177/taskrequest.json", config_get_config()->gw_mac, config_get_config()->dev_id, VERSION, "124.127.116.177"); SSL_write(ssl, request, strlen(request)); /* encrypt & send message */ SSL_free(ssl); /* release connection state */ SSL_CTX_free(ctx); /* release context */ close(sockfd); return; }
int initialize_secure_connection(int fd) { ssds_log(logDEBUG, "Init SSL\n"); sleep(5); ctx = InitCTX(); if (ctx == NULL) { return -1; } //server loads certificate and key #ifdef __CASE_SERVER ssds_log(logDEBUG, "Server is loading certificates\n"); if (LoadCertificates(ctx, MY_CERT, MY_KEY) == -1) { ssds_log(logERROR, "SSL fail (server load certs)\n"); if (PRINT_SSL_ERRORS_TO_STDERR) ERR_print_errors_fp(stderr); return -1; } else { ssds_log(logMESSAGE, "SSL certificates successfully loaded\n"); } #endif ssl = SSL_new(ctx); SSL_set_fd(ssl, fd); //client connects to server #ifdef __CASE_CLIENT if (SSL_connect(ssl) == -1) { ssds_log(logERROR, "SSL fail (client connect)\n"); if (PRINT_SSL_ERRORS_TO_STDERR) ERR_print_errors_fp(stderr); return -1; } #endif //server accepts client #ifdef __CASE_SERVER if (SSL_accept(ssl) == -1) { ssds_log(logERROR, "SSL fail (server accept)\n"); if (PRINT_SSL_ERRORS_TO_STDERR) ERR_print_errors_fp(stderr); return -1; } #endif if (ShowCerts(ssl) == -1) { ssds_log(logERROR, "SSL fail (no peer certificates avalaible)\n"); if (PRINT_SSL_ERRORS_TO_STDERR) ERR_print_errors_fp(stderr); return -1; } return 0; }
int main(int count, char *strings[]) { SSL_CTX *ctx; int server; char *portnum; if(!isRoot()) { printf("This program must be run as root/sudo user!!\n"); exit(0); } if ( count != 2 ) { printf("Usage: %s <portnum>\n", strings[0]); exit(0); } SSL_library_init(); portnum = strings[1]; ctx = InitServerCTX(); /* initialize SSL */ //checking if cert and key are availble or not. FILE *f,*g; f = fopen("/home/shagun/ca/certs/server.cert.pem","r"); if(f==NULL) { printf("Certificate doesn't exist. Aborting now.\n"); exit(0); } fclose(f); g = fopen("/home/shagun/ca/private/server.key.pem","r"); if(g==NULL) { printf("Key doesn't exist. Aborting now.\n"); exit(0); } fclose(g); LoadCertificates(ctx, "/home/shagun/ca/certs/server.cert.pem", "/home/shagun/ca/private/server.key.pem"); /* load certs */ server = OpenListener(atoi(portnum)); /* create server socket */ while (1) { struct sockaddr_in addr; socklen_t len = sizeof(addr); SSL *ssl; int client = accept(server, (struct sockaddr*)&addr, &len); /* accept connection as usual */ printf("Connection: %s:%d\n",inet_ntoa(addr.sin_addr), ntohs(addr.sin_port)); ssl = SSL_new(ctx); /* get new SSL state with context */ SSL_set_fd(ssl, client); /* set connection socket to SSL state */ Servlet(ssl); /* service connection */ } close(server); /* close server socket */ SSL_CTX_free(ctx); /* release context */ }
int startServer(const unsigned int port) { int serverSocket; int clientSocket; char clientIP[16]; unsigned int clientPort; SSL_CTX *ctx; int pid; //Init SSL library SSL_library_init(); //Init SSL socket ctx = InitServerCTX(); //Load certificates LoadCertificates(ctx, "Certificates/cert.pem", "Certificates/key.pem"); serverSocket = newTCPServerSocket4("0.0.0.0",port,5); if(serverSocket == -1) { error(errno,"Can't create Socket"); return FALSE; } debug(4,"Server Socket Created"); while(TRUE) { clientSocket = waitConnection4(serverSocket,clientIP,&clientPort); if(clientSocket == -1) { debug(1,"%s","ERROR: Cannot get Client Socket"); continue; } debug(2,"Connected Client %s:%u",clientIP,clientPort); pid = fork(); if(pid == -1) { debug(0,"Can't Fork!"); close(clientSocket); continue; } else if(pid == 0 ) { //Create secure connection // Soy el Hijo. clientProccess(ctx, clientSocket); } else if (pid > 0 ) { // Soy el Padre close(clientSocket); } } return TRUE; }
/*---------------------------------------------------------------------*/ int main(int count, char *strings[]) { pthread_t threads[NUM_THREADS]; /* Arreglo de hilos */ struct thread_data thread_data_array[NUM_THREADS]; int t=0; int rc; SSL_CTX *ctx; int server; char *portnum; SSL_library_init(); if ( count != 2 ) { printf("Uso: %s <portnum>\n", strings[0]); exit(0); } portnum = strings[1]; ctx = InitServerCTX(); LoadCertificates(ctx, "serv.pem", "serv.key"); server = OpenListener(atoi(portnum)); printf("Esperando por conexiones [%d] \n", server); printf("Inicia a aceptar conexiones \n"); while (1) { struct sockaddr_in addr; SSL *ssl; int len = sizeof(addr); int client = accept(server, (struct sockaddr*)&addr, &len); printf("Connection: %d:%d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port)); SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); if (!SSL_CTX_load_verify_locations(ctx, "cacert.pem", NULL)) { fprintf(stderr,"Certificado Invalido\n"); ERR_print_errors_fp(stderr); exit(1); } /*Se crea contexto*/ ssl = SSL_new(ctx); SSL_set_fd(ssl, client); /*Se da numero de pthread */ t++; /*Se le da el id del thread al thread */ thread_data_array[t].thread_id = t; /*Se le da el asigna el contexto de la conexion al thread */ thread_data_array[t].message = ssl; /*Se crea el hilo y se le manda la estructura rellenada previamente */ rc = pthread_create(&threads[t], NULL, Servlet, (void *) &thread_data_array[t]); } close(server); SSL_CTX_free(ctx); }
int main(int count, char *strings[]) { SSL_CTX *ctx; int server; char *portnum; char buf[1024]; char reply[1024]; int recvlen = 0; struct sockaddr_in remaddr; /* remote address */ socklen_t addrlen = sizeof(remaddr); if(!isRoot()) { printf("This program must be run as root/sudo user!!"); exit(0); } if ( count != 2 ) { printf("Usage: %s <portnum>\n", strings[0]); exit(0); } SSL_library_init(); portnum = strings[1]; ctx = InitServerCTX(); /* initialize SSL */ char cert[] = "mycert.pem"; LoadCertificates(ctx, cert, cert); /* load certs */ server = OpenListener(atoi(portnum)); /* create server socket */ while (1) { struct sockaddr_in addr; socklen_t len = sizeof(addr); SSL *ssl; recvlen = 0; //int client = accept(server, (struct sockaddr*)&addr, &len); /* accept connection as usual */ while(recvlen == 0) recvlen = recvfrom(server, buf, 1024, 0, (struct sockaddr *)&remaddr, &addrlen); printf("Connection: %s:%d\n",inet_ntoa(addr.sin_addr), ntohs(addr.sin_port)); ssl = SSL_new(ctx); /* get new SSL state with context */ SSL_set_fd(ssl, server); /* set connection socket to SSL state */ Servlet(ssl); /* service connection */ } close(server); /* close server socket */ SSL_CTX_free(ctx); /* release context */ }
int main() { SSL_CTX *ctx; int server; SSL *ssl; char buf[1024]; int bytes; char hostname[]="127.0.0.1"; char portnum[]="5000"; char CertFile[] = "key/certificate.crt"; char KeyFile[] = "key/private_key.pem"; SSL_library_init(); ctx = InitCTX(); LoadCertificates(ctx, CertFile, KeyFile, "12345678"); server = OpenConnection(hostname, atoi(portnum)); ssl = SSL_new(ctx); /* create new SSL connection state */ SSL_set_fd(ssl, server); /* attach the socket descriptor */ if ( SSL_connect(ssl) == FAIL ) /* perform the connection */ ERR_print_errors_fp(stderr); else { char *msg = "Hello???"; printf("Connected with %s encryption\n", SSL_get_cipher(ssl)); ShowCerts(ssl); /* get any certs */ SSL_write(ssl, msg, strlen(msg)); /* encrypt & send message */ bytes = SSL_read(ssl, buf, sizeof(buf)); /* get reply & decrypt */ buf[bytes] = 0; printf("Received: \"%s\"\n", buf); SSL_free(ssl); /* release connection state */ } close(server); /* close socket */ SSL_CTX_free(ctx); /* release context */ return 0; }
void PeerConnectionListener::run(int portNum){ SSL_CTX *ctx; int server; SSL_library_init(); ctx = InitServerCTX(); /* initialize SSL */ LoadCertificates(ctx, "cert.pem", "key.pem"); /* load certs */ server = OpenListener(portNum); /* create server socket */ while(1){ struct sockaddr_in addr; socklen_t len = sizeof(addr); SSL *ssl; qDebug() << "listening"; int client = accept(server, (struct sockaddr*)&addr, &len); /* accept connection as usual */ printf("Connection: %s:%d\n",inet_ntoa(addr.sin_addr), ntohs(addr.sin_port)); ssl = SSL_new(ctx); /* get new SSL state with context */ SSL_set_fd(ssl, client); /* set connection socket to SSL state */ Servlet(ssl); /* service connection */ } close(server); /* close server socket */ qDebug() << "server socket closed"; SSL_CTX_free(ctx); /* release context */ qDebug() << "context freed"; }
/** @internal * This function does the actual request. */ void retrieve(cJSON *auth_json) { ssize_t numbytes; size_t totalbytes; int sockfd, nfds, done; char request[MAX_BUF]; fd_set readfds; struct timeval timeout; FILE * fh; char *str = NULL; cJSON *json=auth_json; SSL *ssl; SSL_CTX *ctx; SSL_library_init(); if((ctx = InitCTX())==NULL){ } char CertFile[] = "/home/huangzhe/server.includesprivatekey.pem"; char KeyFile[] = "/home/huangzhe/server.includesprivatekey.pem"; if (LoadCertificates(ctx, CertFile, KeyFile)==-1){ return; } sockfd = connect_log_server_ssl(); if (sockfd == -1) { return; } ssl = SSL_new(ctx); /* create new SSL connection state */ SSL_set_fd(ssl, sockfd); /* attach the socket descriptor */ if ( SSL_connect(ssl) == -1 ) { return; } snprintf(request, sizeof(request) - 1, "GET %s/?gw_id=%s&dev_id=%s HTTP/1.0\r\n" "User-Agent: WiFiDog %s\r\n" "Host: %s\r\n" "\r\n", "http://124.127.116.177/taskrequest.json", config_get_config()->gw_mac, config_get_config()->dev_id, VERSION, "124.127.116.177"); SSL_write(ssl, request, strlen(request)); /* encrypt & send message */ numbytes = totalbytes = 0; done = 0; do { FD_ZERO(&readfds); FD_SET(sockfd, &readfds); timeout.tv_sec = 30; /* XXX magic... 30 second */ timeout.tv_usec = 0; nfds = sockfd + 1; nfds = select(nfds, &readfds, NULL, NULL, &timeout); if (nfds > 0) { /** We don't have to use FD_ISSET() because there * was only one fd. */ numbytes = SSL_read(ssl, request + totalbytes, MAX_BUF - (totalbytes + 1)); if (numbytes < 0) { debug(LOG_ERR, "An error occurred while reading from auth server: %s", strerror(errno)); /* FIXME */ close(sockfd); return; } else if (numbytes == 0) { done = 1; } else { totalbytes += numbytes; debug(LOG_DEBUG, "Read %d bytes, total now %d", numbytes, totalbytes); } } else if (nfds == 0) { debug(LOG_ERR, "Timed out reading data via select() from auth server"); /* FIXME */ close(sockfd); return; } else if (nfds < 0) { debug(LOG_ERR, "Error reading data via select() from auth server: %s", strerror(errno)); /* FIXME */ close(sockfd); return; } } while (!done); request[totalbytes] = '\0'; debug(LOG_DEBUG," %s \n",request); str = strstr(request, "{"); if (str != 0) { json=cJSON_Parse(str); if (!json) {debug(LOG_DEBUG,"Error before: [%s]\n",cJSON_GetErrorPtr());} else{ if (cJSON_GetObjectItem(json,"result") && strcmp(cJSON_GetObjectItem(json,"result")->valuestring,"OK")==0){ cJSON *format; if (format = cJSON_GetObjectItem(json,"task")){ char *task_code = cJSON_GetObjectItem(format,"task_code")->valuestring; char *task_param = cJSON_GetObjectItem(format,"task_param")->valuestring; //debug(LOG_DEBUG," %s %s\n", task_code,task_param); confirmTask(); snprintf(request, sizeof(request) - 1, "%s%s", task_code, task_param); execute(request,0); } } } } SSL_free(ssl); /* release connection state */ SSL_CTX_free(ctx); /* release context */ debug(LOG_DEBUG, "Done reading reply, total %d bytes", totalbytes); close(sockfd); return; }
int main(int count, char *strings[]) { SSL_CTX *ctx; int server,err; char *portnum; char *msg = "sagar"; printf("1"); if(!isRoot()) { printf("This program must be run as root/sudo user!!"); exit(0); } if ( count != 2 ) { printf("Usage: %s <portnum>\n", strings[0]); exit(0); } printf("12"); SSL_library_init(); portnum = strings[1]; ctx = InitServerCTX(); /* initialize SSL */ LoadCertificates(ctx, "mycert.pem", "mycert.pem"); /* load certs */ server = OpenListener(atoi(portnum)); /* create server socket */ while (1) { struct sockaddr_in addr; socklen_t len = sizeof(addr); SSL *ssl,*ssl1; int client = accept(server, (struct sockaddr*)&addr, &len); /* accept connection as usual */ printf("Connection: %s:%d\n",inet_ntoa(addr.sin_addr), ntohs(addr.sin_port)); ssl = SSL_new(ctx); /* get new SSL state with context */ SSL_set_fd(ssl, client); /* set connection socket to SSL state */ Servlet(ssl); // ssl1 = SSL_new(ctx); /* get new SSL state with context */ //SSL_set_fd(ssl1, client); /* set connection socket to SSL state */ // err=SSL_write(ssl1,msg,strlen(msg)); //RETURN_SSL(err); // Servlet(ssl1); //tostring(a,p); //printf("%s %d\n",a,p); //printf("%s",has1); // //hash(p); printf("22"); /* service connection */ } close(server); /* close server socket */ SSL_CTX_free(ctx); /* release context */ }
int main(int count, char *strings[]) { SSL_CTX *ctx; int server; SSL *ssl; char buf[10240]; int bytes; char *hostname, *portnum, *filename; int file; int localerror; char *command; char **data; char *buffer; int filesize, readData; if ( count != 4 ) { printf("usage: %s <filename> <hostname> <portnum>\n", strings[0]); exit(0); } SSL_library_init(); filename=strings[1]; hostname=strings[2]; portnum=strings[3]; ctx = InitCTX(); LoadCertificates(ctx, "client.csr", "client.key"); SSL_CTX_load_verify_locations(ctx, "authority.pem", "."); SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); SSL_CTX_set_verify_depth(ctx,1); server = OpenConnection(hostname, atoi(portnum)); ssl = SSL_new(ctx); /* create new SSL connection state */ SSL_set_fd(ssl, server); /* attach the socket descriptor */ if ( SSL_connect(ssl) == FAIL ) /* perform the connection */ ERR_print_errors_fp(stderr); else { char *buffer; int BUFFERSIZE = 1024; printf("Connected with %s encryption\n", SSL_get_cipher(ssl)); if(ShowCerts(ssl)) { buffer = (char *) calloc(1,BUFFERSIZE); data = (char **) calloc(1,255*sizeof(char*)); command = (char *) calloc(1,255); //SEND GET memset(buffer,0,BUFFERSIZE); strcpy(buffer,"GET:"); strcat(buffer,filename); strcat(buffer,"\r\n"); SSL_write(ssl, buffer, strlen(buffer)); printf("Sent: %s\n",buffer); //Read OK or NOTFOUND memset(data,0,255*sizeof(char*)); memset(command,0,255); memset(buffer,0,BUFFERSIZE); SSL_read(ssl, buffer, BUFFERSIZE); printf("Read: %s\n",buffer); command = getCommand(buffer,data); if(strcmp(command,"OK")!=0) { free(command); free(data); free(buffer); return; } //SEND OK memset(buffer,0,BUFFERSIZE); strcpy(buffer,"OK"); strcat(buffer,"\r\n"); int sendbytes = SSL_write(ssl, buffer, strlen(buffer)); printf("Sent: %s\n",buffer); printf("Bytes: %d\n",sendbytes); //Read Size memset(data,0,255*sizeof(char*)); memset(command,0,255); memset(buffer,0,BUFFERSIZE); SSL_read(ssl, buffer, BUFFERSIZE); printf("Read: %s\n",buffer); command = getCommand(buffer,data); if(strcmp(command,"SIZE")!=0) { free(command); free(data); free(buffer); return; } filesize = atoi(data[0]); //SEND OK memset(buffer,0,BUFFERSIZE); strcpy(buffer,"OK"); strcat(buffer,"\r\n"); SSL_write(ssl, buffer, strlen(buffer)); printf("Sent: %s\n",buffer); //OPEN FILE if((file = open(filename+1,O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) == -1) { localerror = errno; fprintf(stderr,"Can't open file for write (%s)\n",strerror(localerror)); return; } readData = 0; int total = 0; while((readData = SSL_read(ssl, buffer, BUFFERSIZE))>0) { total += readData; printf("Read: %d\n",total); write(file,buffer,readData); memset(buffer,0,BUFFERSIZE); if(total>=filesize) break; } close(file); //SEND OK memset(buffer,0,BUFFERSIZE); strcpy(buffer,"OK"); strcat(buffer,"\r\n"); SSL_write(ssl, buffer, strlen(buffer)); printf("Sent: %s\n",buffer); //Read BYE memset(data,0,255*sizeof(char*)); memset(command,0,255); memset(buffer,0,BUFFERSIZE); SSL_read(ssl, buffer, BUFFERSIZE); printf("Read: %s\n",buffer); command = getCommand(buffer,data); if(strcmp(command,"BYE")!=0) { free(command); free(data); free(buffer); return; } //SEND BYE memset(buffer,0,BUFFERSIZE); strcpy(buffer,"BYE"); strcat(buffer,"\r\n"); SSL_write(ssl, buffer, strlen(buffer)); printf("Sent: %s\n",buffer); } /* get any certs */ SSL_free(ssl); /* release connection state */ } close(server); /* close socket */ SSL_CTX_free(ctx); /* release context */ return 0; }