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