int open_connection( SSL **ssl, SSL_CTX **ctx, char *server_addr, char *server_port)
{
BIO *conn;
long err;
char addr_buf[100] = "";
sprintf(addr_buf, "%s:%s", server_addr, server_port);
printf("[%s]\n",addr_buf);
*ctx = setup_client_ctx( );
conn = BIO_new_connect(addr_buf);
if (!conn)
handle_error("Error creating connection BIO");
if (BIO_do_connect(conn) <= 0)
handle_error("Error connecting to remote machine");
*ssl = SSL_new(*ctx);
SSL_set_bio(*ssl, conn, conn);
if (SSL_connect(*ssl) <= 0)
handle_error("Error connecting SSL object");
if ((err = post_connection_check(*ssl, SERVER)) != X509_V_OK)
{
fprintf(stderr, "-Error: peer certificate: %s\n",
X509_verify_cert_error_string(err));
handle_error("Error checking SSL object after connection");
}
fprintf(stderr, "SSL Connection opened\n");
return 0;
}
static boolean connect_to_emergency_phr_list_loading_service(SSL **ssl_conn_ret)
{
BIO *bio_conn = NULL;
SSL_CTX *ctx = NULL;
int err;
char *hosts[1];
char phr_server_addr[IP_ADDRESS_LENGTH + PORT_NUMBER_LENGTH + 2];
// Connect to PHR Server
sprintf(phr_server_addr, "%s:%s", GLOBAL_phr_server_ip_addr, PHRSV_EMERGENCY_PHR_LIST_LOADING_PORT);
bio_conn = BIO_new_connect(phr_server_addr);
if(!bio_conn)
int_error("Creating BIO connection failed");
if(BIO_do_connect(bio_conn) <= 0)
{
fprintf(stderr, "Connecting to PHR server failed\n");
goto ERROR_AT_BIO_LAYER;
}
ctx = setup_client_ctx(EMS_CERTFILE_PATH, EMS_CERTFILE_PASSWD, PHR_ROOT_CA_ONLY_CERT_CERTFILE_PATH);
if(!(*ssl_conn_ret = SSL_new(ctx)))
int_error("Creating SSL context failed");
SSL_set_bio(*ssl_conn_ret, bio_conn, bio_conn);
if(SSL_connect(*ssl_conn_ret) <= 0)
{
fprintf(stderr, "Connecting SSL object failed\n");
goto ERROR_AT_SSL_LAYER;
}
hosts[0] = PHR_SERVER_CN;
if((err = post_connection_check(*ssl_conn_ret, hosts, 1, false, NULL)) != X509_V_OK)
{
fprintf(stderr, "Checking peer certificate failed\n\"%s\"\n", X509_verify_cert_error_string(err));
goto ERROR_AT_SSL_LAYER;
}
// Return value of *ssl_conn_ret
SSL_CTX_free(ctx);
ERR_remove_state(0);
return true;
ERROR_AT_BIO_LAYER:
BIO_free(bio_conn);
bio_conn = NULL;
ERR_remove_state(0);
return false;
ERROR_AT_SSL_LAYER:
SSL_cleanup(*ssl_conn_ret);
*ssl_conn_ret = NULL;
SSL_CTX_free(ctx);
ERR_remove_state(0);
return false;
}
static boolean connect_to_phr_transaction_log_synchronization_service(SSL **ssl_conn_ret)
{
BIO *bio_conn = NULL;
SSL_CTX *ctx = NULL;
int err;
char *hosts[1];
char audit_server_addr[IP_ADDRESS_LENGTH + PORT_NUMBER_LENGTH + 2];
// Connect to Audit Server
sprintf(audit_server_addr, "%s:%s", GLOBAL_audit_server_ip_addr, AS_PHR_TRANSACTION_LOG_SYNCHRONIZATION_PORT);
bio_conn = BIO_new_connect(audit_server_addr);
if(!bio_conn)
int_error("Creating BIO connection failed");
if(BIO_do_connect(bio_conn) <= 0)
{
fprintf(stderr, "Connecting to audit server failed\n");
goto ERROR_AT_BIO_LAYER;
}
ctx = setup_client_ctx(UA_CERTFILE_PATH, UA_CERTFILE_PASSWD, PHR_ROOT_CA_ONLY_CERT_CERTFILE_PATH);
if(!(*ssl_conn_ret = SSL_new(ctx)))
int_error("Creating SSL context failed");
SSL_set_bio(*ssl_conn_ret, bio_conn, bio_conn);
if(SSL_connect(*ssl_conn_ret) <= 0)
{
fprintf(stderr, "Connecting SSL object failed\n");
goto ERROR_AT_SSL_LAYER;
}
hosts[0] = AUDIT_SERVER_CN;
if((err = post_connection_check(*ssl_conn_ret, hosts, 1, true, GLOBAL_authority_name)) != X509_V_OK)
{
fprintf(stderr, "Checking peer certificate failed\n\"%s\"\n", X509_verify_cert_error_string(err));
goto ERROR_AT_SSL_LAYER;
}
// Return value of *ssl_conn_ret
SSL_CTX_free(ctx);
ERR_remove_state(0);
return true;
ERROR_AT_BIO_LAYER:
BIO_free(bio_conn);
bio_conn = NULL;
ERR_remove_state(0);
return false;
ERROR_AT_SSL_LAYER:
SSL_cleanup(*ssl_conn_ret);
*ssl_conn_ret = NULL;
SSL_CTX_free(ctx);
ERR_remove_state(0);
return false;
}
int main (int argc, const char * argv[])
{
// char token[] = "2b2474e5 ac7670f3 08fabf3a 9c1d1295 ed50e9aa f11b941a d6e3d213 4f535408";
char *token ="aa994d28c89422d11c58ba4ab6d18309427699719e6f208395d0d5a40eb90d21";
char payload[] = "{\"aps\":{\"alert\":\"Hello world!!!\",\"badge\":1}}";
char payload2[] = "{\"aps\":{\"alert\":\"Hello kitty!!!\",\"badge\":12}}";
char host[] = "gateway.sandbox.push.apple.com:2195";
BIO *conn;
// init
SSL_library_init();
ctx = setup_client_ctx();
conn = BIO_new_connect(host);
if (!conn) {
error("Error creating connection BIO\n");
}
if (BIO_do_connect(conn) <= 0) {
error("Error connection to remote machine");
}
if (!(ssl = SSL_new(ctx))) {
error("Error creating an SSL contexxt");
}
SSL_set_bio(ssl, conn, conn);
if (SSL_connect(ssl) <= 0) {
error("Error connecting SSL object");
}
printf("SSL Connection opened\n");
// push message
int ret = push(token, payload);
printf("push ret[%d]\n", ret);
// push [Hello kitty] after 5s
sleep(5);
ret = push(token, payload2);
printf("push2 ret[%d]\n", ret);
char buf[256];
SSL_read(ssl, buf, 256);
printf("Close SSL Connection\n");
SSL_shutdown(ssl);
SSL_free(ssl);
SSL_CTX_free(ctx);
return 0;
}
int main_ssl(int argc, char **argv)
{
BIO *conn;
SSL *ssl;
SSL_CTX *ctx;
long err;
init_OpenSSL();
seed_prng();
ctx = setup_client_ctx();
fprintf(stderr, "SERVER= %s:%s\n", SERVER, PORT);
conn = BIO_new_connect(SERVER ":" PORT);
if (!conn)
int_error("Error creating connection BIO");
if (BIO_do_connect(conn) <= 0)
int_error("Error connecting to remote machine");
ssl = SSL_new(ctx);
SSL_set_bio(ssl, conn, conn);
if (SSL_connect(ssl) <= 0)
int_error("Error connecting SSL object");
if ((err = post_connection_check(ssl, SERVER)) != X509_V_OK) {
fprintf(stderr, "-Error: peer certificate: %s\n",
X509_verify_cert_error_string(err));
int_error("Error checking SSL object after connection");
}
fprintf(stderr, "SSL Connection opened\n");
if (do_client_loop(ssl))
SSL_shutdown(ssl);
else
SSL_clear(ssl);
fprintf(stderr, "SSL Connection closed\n");
SSL_free(ssl);
SSL_CTX_free(ctx);
return 0;
}
SSL *
connect_client (int port, const char *addr, int addr_family)
{
int sd;
int err;
int result = -1;
/* SSL preliminaries */
SSL_CTX* ctx;
SSL* ssl;
init_OpenSSL ();
seed_prng ();
sd = crv_client_create(port, addr, addr_family);
/* We keep the certificate and key with the context. */
ctx = setup_client_ctx ();
/* TCP connection is ready. Do server side SSL. */
ssl = SSL_new (ctx);
if ((ssl)==NULL) {
fprintf ( stderr, "%s\n", "Create new ssl failed");
}
/* connect the SSL object with a file descriptor */
err = SSL_set_fd (ssl, sd);
if ((err)==0) {
fprintf ( stderr, "%s\n", "Put SSL on socket failed \n");
close(sd);
}
result = SSL_connect (ssl);
if (result == 0) {
SSL_get_error(ssl, result);
return (NULL);
} else
if (result == -1) {
fprintf( stderr, "%s\n", "client_(): Err[003] SSL_connect() failed");
return (NULL);
}
return (ssl);
}
int main(int argc, char **argv)
{
BIO *conn;
SSL *ssl;
SSL_CTX *ctx;
init_openssl();
seed_prng(64);
ctx = setup_client_ctx();
conn = BIO_new_connect(SERVER ":" PORT);
if(!conn)
log_err("Failed create bio connection");
if(BIO_do_connect(conn) <= 0)
log_err("Failed connecting to remote host");
if(!(ssl = SSL_new(ctx)))
log_err("Error creating an SSL context.");
SSL_set_bio(ssl, conn, conn);
if(SSL_connect(ssl) <= 0)
log_err("Error connecting SSL object.");
fprintf(stderr, "Connection opened\n");
if(do_client(ssl))
SSL_shutdown(ssl);
else
SSL_clear(ssl);
fprintf(stderr, "Connection closed\n");
//BIO_free(conn);
SSL_free(ssl);
SSL_CTX_free(ctx);
return 0;
}
static boolean connect_to_restricted_level_phr_access_request_responding_service(SSL **ssl_conn_ret)
{
BIO *bio_conn = NULL;
SSL_CTX *ctx = NULL;
int err;
char *hosts[1];
char emergency_server_addr[IP_ADDRESS_LENGTH + PORT_NUMBER_LENGTH + 2];
// Connect to Emergency Server
sprintf(emergency_server_addr, "%s:%s", GLOBAL_emergency_server_ip_addr, EMS_RESTRICTED_LEVEL_PHR_ACCESS_REQUEST_RESPONDING_PORT);
bio_conn = BIO_new_connect(emergency_server_addr);
if(!bio_conn)
int_error("Creating BIO connection failed");
if(BIO_do_connect(bio_conn) <= 0)
{
backend_alert_msg_callback_handler("Connecting to emergency server failed");
goto ERROR_AT_BIO_LAYER;
}
/* Hash value is used for verifying an SSL certificate to make sure that certificate is a latest update version,
preventing a user uses a revoked certificate to feign to be a revoked one */
if(!verify_file_integrity(SSL_CERT_PATH, GLOBAL_ssl_cert_hash, CALCULATING_SSL_CERT_HASH_PATH))
{
// Notify alert message to user and then terminate the application
backend_fatal_alert_msg_handler_callback("Your SSL certificate is not verified.\nTo solve this, please contact an administrator.");
}
ctx = setup_client_ctx(SSL_CERT_PATH, GLOBAL_passwd, PHR_ROOT_CA_ONLY_CERT_CERTFILE_PATH);
if(!(*ssl_conn_ret = SSL_new(ctx)))
int_error("Creating SSL context failed");
SSL_set_bio(*ssl_conn_ret, bio_conn, bio_conn);
if(SSL_connect(*ssl_conn_ret) <= 0)
{
backend_alert_msg_handler_callback("Connecting SSL object failed");
goto ERROR_AT_SSL_LAYER;
}
hosts[0] = EMERGENCY_SERVER_CN;
if((err = post_connection_check(*ssl_conn_ret, hosts, 1, true, GLOBAL_authority_name)) != X509_V_OK)
{
fprintf(stderr, "Checking peer certificate failed\n\"%s\"\n", X509_verify_cert_error_string(err));
backend_alert_msg_handler_callback("Checking SSL information failed");
goto ERROR_AT_SSL_LAYER;
}
// Return value of *ssl_conn_ret
SSL_CTX_free(ctx);
ERR_remove_state(0);
return true;
ERROR_AT_BIO_LAYER:
BIO_free(bio_conn);
bio_conn = NULL;
ERR_remove_state(0);
return false;
ERROR_AT_SSL_LAYER:
SSL_cleanup(*ssl_conn_ret);
*ssl_conn_ret = NULL;
SSL_CTX_free(ctx);
ERR_remove_state(0);
return false;
}
static void
receive_sync_file (void *arg)
{
int sd;
int code = 0;
int port;
int i;
long lval;
char command[SIZE];
char *sync_arg = arg;
char buf[4096];
char *ep = NULL;
char host_port[SIZE];
char **c = NULL;
FILE *fd = NULL;
SSL_CTX* ctx;
SSL* ssl;
c = crv_cut (sync_arg, ":");
lval = strtol(c[1], &ep, 10);
if (c[0][0] == '\0' || *ep != '\0') {
fprintf(stderr, "%s\n", "Sync(): Err[002] Check port on serveur_liste");
return ;
}
if (lval > 65535 || lval < 0) {
fprintf(stderr, "%s\n", "Sync(): Err[003] Check port on serveur_liste");
return ;
}
port = lval;
crv_strncpy (host_port, "./listing/", sizeof(host_port));
crv_strncat (host_port, c[0], sizeof(host_port)); /* put server name in host_port */
crv_strncat (host_port, ".db", sizeof(host_port)); /* add : behind server name */
fprintf (stdout, "%s", "Listing reception on ");
fflush(stdout);
#ifndef WIN32
couleur ("33;31");
#else
couleur (12, 0);
#endif
fprintf (stdout, "'%s'", c[0]);
fflush(stdout);
#ifndef WIN32
couleur ("0");
#else
couleur (15, 0);
#endif
fprintf (stdout, "%s\n", " is running ...");
/* SSL preliminaries */
init_OpenSSL ();
seed_prng ();
sd = crv_client_create(port, c[0], options.address_family);
if (sd == -1) {
close(sd);
pthread_exit(NULL);
}
/* We keep the certificate and key with the context. */
ctx = setup_client_ctx ();
/* TCP connection is ready. Do server side SSL. */
ssl = SSL_new (ctx);
if ((ssl)==NULL) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_sync_file() Err[001] Create new ssl failed");
pthread_exit(NULL);
}
/* connect the SSL object with a file descriptor */
code = SSL_set_fd (ssl, sd);
if ( code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_sync_file() Err[002] Put SSL on socket failed \n");
pthread_exit(NULL);
}
code = SSL_connect (ssl);
if (code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "receive_sync_file(): Err[003] SSL_connect() failed");
pthread_exit (NULL);
} else
if (code == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "receive_sync_file(): Err[004] SSL_connect() failed");
pthread_exit (NULL);
}
#ifndef WIN32
/*
code = post_connection_check (ssl, c[0]);
if (code != X509_V_OK)
{
fprintf (stderr, "-Error: peer certificate: %s\n", X509_verify_cert_error_string (code));
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "receive_sync_file(): Err[004'] post_connection_check() failed");
pthread_exit (NULL);
}
*/
#endif
for (i = 0; c[i]; i++)
crv_free(c[i]);
fd = crv_fopen(host_port, "w");
if (fd == NULL) {
fclose(fd); close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_sync_file(): Err[005] crv_fopen() failed");
pthread_exit (NULL);
}
/* Build command -> SYNC#version */
(void)crv_strncpy(command, "SYNC#", sizeof(command));
(void)crv_strncat(command, CREUVUX_VERSION, sizeof(command));
code = SSL_write (ssl, command, (int)strlen(command));
if ( code <= 0) {
fclose(fd); close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_sync_file(): Err[006] SSL_write() failed.");
pthread_exit(NULL);
}
code = SSL_read (ssl, buf, sizeof(buf) - 1);
buf[code] = '\0';
if(!strncmp (buf, "SYNC_ACK", strlen("SYNC_ACK")))
{
for (;;)
{
code = SSL_read (ssl, buf, sizeof (buf));
switch (SSL_get_error (ssl, code))
{
case SSL_ERROR_NONE:
case SSL_ERROR_ZERO_RETURN:
case SSL_ERROR_WANT_READ:
case SSL_ERROR_WANT_WRITE:
break;
default:
fclose(fd); close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "0)Can't receive LISTING\n");
pthread_exit (NULL);
}
if (!strncmp (buf, "SYNC_END", strlen("SYNC_END"))) {
break;
}
code = fwrite (&buf, (size_t) code, 1, fd);
if (code <= 0) {
fclose(fd); close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "1)Can't write LISTING file\n");
pthread_exit (NULL);
}
}
}
fclose(fd);
close (sd);
SSL_free (ssl);
SSL_CTX_free (ctx);
pthread_exit (NULL);
}
int Gtk_Put(const char *filename, const char *file_descrip, const char *server, const char *Sha1)
{
SSL_CTX* ctx = NULL;
SSL* ssl = NULL;
int sd = -1;
int port = -1;
char *ep;
long lval;
int code = -1;
off_t size = 0;
char command[SIZE];
char buf[SIZE];
char size_c [SIZE];
char *dscr = NULL;
char *sha1 = NULL;
char **a = NULL;
int descr_fd = 0;
errno = 0;
/* ETA */
struct timeval tv1, tv2;
int sec1;
init_OpenSSL ();
seed_prng ();
size = crv_du (filename);
if (size == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[007] crv_du() can't get size");
return(-1);
}
snprintf(size_c, sizeof(size), "%lld", size);
a = crv_cut(server, ":");
lval = strtol(a[1], &ep, 10);
if (a[1][0] == '\0' || *ep != '\0') {
fprintf(stderr, "%s\n", "Put(): Err[001] port is not a number");
return (-1);
}
if ((errno == ERANGE && (lval == LONG_MAX
|| lval == LONG_MIN)) ||
(lval > 65535 || lval < 0))
{
fprintf(stderr, "%s\n", "Put(): Err[002] port is out of range");
return (-1);
}
port = lval;
sd = crv_client_create( port, a[0], options.address_family);
/* We keep the certificate and key with the context. */
ctx = setup_client_ctx ();
/* TCP connection is ready. Do server side SSL. */
ssl = SSL_new (ctx);
if ((ssl)==NULL) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[003] Create new ssl failed");
return(-1);
}
/* connect the SSL object with a file descriptor */
code = SSL_set_fd (ssl, sd);
if ( code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[004] Put SSL on socket failed \n");
return(-1);
}
code = SSL_connect (ssl);
if (code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[005] SSL_connect() failed");
return(-1);
} else
if (code == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[006] SSL_connect() failed");
return(-1);
}
/* Build command -> GET#version#sha1#begin#end */
(void)crv_strncpy(command, "PUT#", sizeof(command));
(void)crv_strncat(command, CREUVUX_VERSION, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, Sha1, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, "0", sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, size_c, sizeof(command));
/* Time initialisation */
gettimeofday (&tv1, NULL);
code = SSL_write (ssl, command, (int)strlen(command));
if ( code <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[011] SSL_write() failed.");
return(-1);
}
code = SSL_read (ssl, buf, sizeof(buf) - 1);
buf[code] = '\0';
if(!crv_strncmp (buf, "PUT_ACK"))
{
fprintf(stdout, "\n\n");
code = SSL_sendfile(ssl, Sha1, filename, (off_t)0, size);
if (code == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[012] SSL_sendfile() failed");
return(-1);
}
}
code = SSL_write (ssl, "PUT_END", (int)strlen("PUT_END"));
if ( code <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[013] SSL_write() failed.");
return(-1);
}
gettimeofday (&tv2, NULL);
/* compute difference */
sec1 = tv2.tv_sec - tv1.tv_sec;
int min;
float average;
average = ((float) size / (float) sec1) / 1024;
min = sec1 / 60;
sec1 = sec1 - min * 60;
fprintf (stdout,
"\n\nFile download in %d min %d sec \nSpeed average -> %.f KBps\n\n",
min, sec1, average);
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
/* Send file's decription */
init_OpenSSL ();
seed_prng ();
sd = crv_client_create( port, a[0], options.address_family);
/* We keep the certificate and key with the context. */
ctx = setup_client_ctx ();
/* TCP connection is ready. Do server side SSL. */
ssl = SSL_new (ctx);
if ((ssl)==NULL) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[003] Create new ssl failed");
return(-1);
}
/* connect the SSL object with a file descriptor */
code = SSL_set_fd (ssl, sd);
if ( code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[004] Put SSL on socket failed \n");
return(-1);
}
code = SSL_connect (ssl);
if (code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[005] SSL_connect() failed");
return(-1);
} else
if (code == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[006] SSL_connect() failed");
return(-1);
}
fprintf(stderr, "File: '%s'\n", file_descrip);
size = -1;
size = crv_du (file_descrip);
fprintf(stderr, "Size: '%lld'\n", size);
if (size == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[007] crv_du() can't get size");
return(-1);
}
memset(size_c, 0, sizeof(size_c));
snprintf(size_c, sizeof(size), "%lld", size);
sha1 = crv_sha1(file_descrip);
/* Build command -> GET#version#sha1#begin#end */
(void)crv_strncpy(command, "COMMENT#", sizeof(command));
(void)crv_strncat(command, CREUVUX_VERSION, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, sha1, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, "0", sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, size_c, sizeof(command));
fprintf(stderr, "CMD:'%s'\n", command);
code = SSL_write (ssl, command, (int)strlen(command));
if ( code <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[011] SSL_write() failed.");
return(-1);
}
code = SSL_read (ssl, buf, sizeof(buf) - 1);
buf[code] = '\0';
if(!strncmp (buf, "PUT_ACK", strlen("PUT_ACK")))
{
code = SSL_sendfile(ssl, sha1, file_descrip, (off_t)0, size);
if (code == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[012] SSL_sendfile() failed");
return(-1);
}
}
code = SSL_write (ssl, "PUT_END", (int)strlen("PUT_END"));
if ( code <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[013] SSL_write() failed.");
return(-1);
}
fprintf(stdout, "%s", "Information about file is uploaded\n");
code = unlink((const char *)file_descrip);
if (code == -1) {
fprintf(stderr, "%s%s\n",
"Put(): Err[010] unlink() failed with error -> ",
strerror(errno));
return (-1);
}
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);crv_free(sha1);
return (0);
}
int Msg(const char *id)
{
FILE *fd = NULL;
char buf[SIZE];
char command[SIZE];
int result = -1;
off_t size;
char size_c[SIZE];
SSL_CTX* ctx = NULL;
SSL* ssl = NULL;
int sd = -1;
errno = 0;
sha1 = NULL; /* Sha1 for wanted ID */
server = NULL;/* server for wanted ID */
port = 0; /* port for Wanted ID*/
/* Get info about file */
get_server_info(id);
get_sha1(id);
fd = crv_fopen(sha1, "w");
if (fd == NULL) {
fprintf( stderr, "%s\n", "Msg(): Err[001] crv_fopen() failed");
return (-1);
}
fprintf(fd, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
fprintf(fd, "<comment><![CDATA[");
fprintf(stdout, "%s", "\nEntrez votre reponse(':wq' pour quitter)\n");
fprintf(stdout, "%s", ">");
while (fgets(buf, sizeof(buf), stdin) != NULL) {
buf[strcspn(buf, "\n")] = '\0';
if (!crv_strncmp(buf, ":wq"))
break;
fprintf(fd, "%s\n", buf);
fprintf(stdout, "%s", ">");
}
fprintf(fd, "]]></comment>\n");
fclose(fd);
/*
* Build command -> GET#version#sha1#begin#end
*/
size = crv_du (sha1);
if (size == -1) {
fprintf( stderr, "%s\n", "Put(): Err[002] crv_du() can't get size");
return(-1);
}
snprintf(size_c, sizeof(size), "%lld", size);
(void)crv_strncpy(command, "MSG_REPLY#", sizeof(command));
(void)crv_strncat(command, CREUVUX_VERSION, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, sha1, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, "0", sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, size_c, sizeof(command));
/*
* Connection.
*/
init_OpenSSL ();
seed_prng ();
sd = crv_client_create( port, server, options.address_family);
/* We keep the certificate and key with the context. */
ctx = setup_client_ctx ();
/* TCP connection is ready. Do server side SSL. */
ssl = SSL_new (ctx);
if ((ssl)==NULL) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Msg() Err[003] Create new ssl failed");
return(-1);
}
/* connect the SSL object with a file descriptor */
result = SSL_set_fd (ssl, sd);
if ( result == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Msg() Err[004] Put SSL on socket failed \n");
return(-1);
}
result = SSL_connect (ssl);
if (result == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Msg(): Err[005] SSL_connect() failed");
return(-1);
} else
if (result == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Msg(): Err[006] SSL_connect() failed");
return(-1);
}
result = SSL_write (ssl, command, (int)strlen(command));
if ( result <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[011] SSL_write() failed.");
return(-1);
}
result = SSL_read (ssl, buf, sizeof(buf) - 1);
buf[result] = '\0';
if(!strncmp (buf, "PUT_ACK", strlen("PUT_ACK")))
{
fprintf(stdout, "\n\n");
result = SSL_sendfile(ssl, NULL, sha1, (off_t)0, size);
if (result == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[012] SSL_sendfile() failed");
return(-1);
}
}
result = SSL_write (ssl, "PUT_END", (int)strlen("PUT_END"));
if ( result <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[013] SSL_write() failed.");
return(-1);
}
result = unlink((const char *)sha1);
if (result == -1) {
fprintf(stderr, "%s%s\n",
"Msg(): Err[007] unlink() failed with error -> ",
strerror(errno));
return (-1);
}
return (0);
}
static int Put(sqlite3 *db, const char *filename, const char *server, const char *grp, const char *username, const char *genre)
{
SSL_CTX* ctx = NULL;
SSL* ssl = NULL;
FILE *fd = NULL;
int sd = -1;
int port = -1;
char *ep;
long lval;
int code = -1;
off_t size = 0;
char command[SIZE];
char buf[SIZE];
char size_c [SIZE];
char *dscr = NULL;
char *sha1 = NULL;
char **a = NULL;
char *blob = NULL;
char dbname[SIZE];
char msg[4096];
int descr_fd = 0;
errno = 0;
/* ETA */
struct timeval tv1, tv2;
int sec1;
/* On ouvre le fichier pour voir si il existe */
if ((fd = fopen (filename, "rb")) == NULL)
{
fprintf (stderr, "Le fichier '%s' peut pas etre ouvert\n", filename);
fprintf (stderr, "Verifiez les droits et son emplacements\n");
exit (EXIT_FAILURE);
}
fclose (fd);
char *real_name = NULL;
real_name = basename((const char *)filename);
if (real_name == NULL)
return (NULL);
size = crv_du (filename);
if (size == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[007] crv_du() can't get size");
return(-1);
}
snprintf(size_c, sizeof(size), "%lld", size);
fprintf(stdout, "%s\n", "Determination de la signature numerique du fichier en cours ...");
sha1 = crv_sha1(filename);
/* Create info's file */
(void)crv_strncpy (dbname, sha1, sizeof(dbname));
(void)crv_strncat (dbname, ".db", sizeof (dbname));
if (many_files != 1) {
int rep;
fprintf (stdout, "Voulez-vous mettre des informations ? (o/n) :"); fflush(stdout);
rep = fgetc (stdin);
rep = toupper (rep);
if (rep == 'O')
{
(void)crv_strncpy(msg, "", sizeof(msg));
fprintf(stdout, "%s", "\nEntrez les informations du fichier (':wq' pour quitter)\n");
fprintf(stdout, "%s", ">");
memset(buf, 0, sizeof(buf));
while (fgets(buf, sizeof(buf), stdin) != NULL) {
if (!crv_strncmp(buf, ":wq\n"))
break;
(void)crv_strncat(msg, buf, sizeof(msg));
fprintf(stdout, "%s", ">");
}
}
}
{
int rep1;
rep1 = -1;
fprintf (stdout, "Voulez-vous mettre un Thumbnail ? (o/n) :"); fflush(stdout);
rep1 = fgetc (stdin);
rep1 = toupper (rep1);
if (rep1 == 'O')
{
fprintf(stdout, "%s", "\nEntrez le chemin du fichier ('Enter' pour valider)\n");
fprintf(stdout, "%s", ">");
memset(buf, 0, sizeof(buf));
while (fgets(buf, sizeof(buf), stdin) != NULL) {
buf[strcspn(buf, "\n")] = '\0';
if (strlen(buf) > 1)
break;
}
blob = crv_strdup(buf);
}
}
size = crv_du (filename);
if (size == -1) {
fprintf( stderr, "%s\n", "Put(): Err[007] crv_du() can't get size");
return(-1);
}
memset(size_c, 0, sizeof(size_c));
snprintf(size_c, sizeof(size_c), "%lld", size);
/*
fprintf (stdout, "DEBUG: DB Name='%s'\n", dbname);
fprintf (stdout, "DEBUG: Sha1='%s'\n", sha1);
fprintf (stdout, "DEBUG: Titre='%s'\n", real_name);
fprintf (stdout, "DEBUG: Size='%s'\n", size_c);
fprintf (stdout, "DEBUG: Pseudo='%s'\n", username);
fprintf (stdout, "DEBUG: Message=\n`-> %s\n", msg);
*/
/*
* Database for file creation
*/
char *zErrMsg = 0;
int rc = -1;
char *req = NULL;
sqlite3 *db_put;
/* Open MAIN Database */
rc = sqlite3_open( dbname, &db_put);
if( rc ){
fprintf(stderr, "Can't open database: %s", sqlite3_errmsg(db_put));
sqlite3_close(db_put);
return (-1);
}
/* Create Tables */
if (create_db (db_put) == -1) {
fprintf(stderr, "%s\n", "Put(): Database creation Failed");
return (-1);
}
/* Fill Files tables*/
/* CREATE TABLE Files (Sha1 TEXT NOT NULL, Name TEXT NOT NULL, Size NUMERIC NOT NULL); */
req = sqlite3_mprintf("INSERT into Files (Sha1, Name, Size) values ('%q', '%q', '%q')", sha1, real_name, size_c);
rc = sqlite3_exec(db_put, req, NULL, 0, &zErrMsg);
if( rc!=SQLITE_OK ){
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
}
/* CREATE TABLE Categories (Sha1 TEXT NOT NULL, Cat TEXT NOT NULL); */
req = sqlite3_mprintf("INSERT into Categories (Sha1, Cat) values ('%q', '%q')", sha1, genre);
rc = sqlite3_exec(db_put, req, NULL, 0, &zErrMsg);
if( rc!=SQLITE_OK ){
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
}
/* CREATE TABLE Descr (Sha1 TEXT NOT NULL, Descr LONGTEXT NOT NULL); */
if (strlen(msg) > 0) {
req = sqlite3_mprintf("INSERT into Descr (Sha1, Descr) values ('%q', '%q')", sha1, msg);
} else
req = sqlite3_mprintf("INSERT into Descr (Sha1, Descr) values ('%q', '')", sha1);
rc = sqlite3_exec(db_put, req, NULL, 0, &zErrMsg);
if( rc!=SQLITE_OK ){
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
}
/* CREATE TABLE Grp_Sha1 (groupname TEXT NOT NULL, sha1 TEXT NOT NULL); */
req = sqlite3_mprintf("INSERT into Grp_Sha1 (groupname, sha1) values ('%q', '%q')", grp, sha1);
rc = sqlite3_exec(db_put, req, NULL, 0, &zErrMsg);
if( rc!=SQLITE_OK ){
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
}
/* CREATE TABLE Grp_User (groupname TEXT NOT NULL, username TEXT NOT NULL); */
if (username != NULL) {
req = sqlite3_mprintf("INSERT into Grp_User (groupname, username) values ('%q', '%q')", grp, username);
rc = sqlite3_exec(db_put, req, NULL, 0, &zErrMsg);
if( rc!=SQLITE_OK ){
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
}
}
/* CREATE TABLE Blob_Data (blob_title varchar(80), b blob); */
/* insert into blobtest (des,b) values ('A test file: test.png',?); */
if (blob != NULL) {
int fd, n, i;
long buflen = 0, totread = 0;
char *bbuf = NULL, *pbuf = NULL;
sqlite3_stmt *plineInfo = 0;
if ((fd = open( blob, O_RDWR | O_CREAT, 0600)) == -1) {
fprintf(stderr, "Can't open Blob: %s\n", strerror(errno));
return 1;
}
while (buflen - totread - 1 < 1024)
buflen = addmem(&bbuf, buflen);
pbuf = bbuf;
totread = 0;
while ((n = read(fd, pbuf, 1024)) > 0) {
totread += n;
pbuf[n] = '\0'; // This is for printing test
while (buflen - totread - 1 < 1024)
buflen = addmem(&bbuf, buflen);
pbuf = &bbuf[totread];
}
close(fd);
req = sqlite3_mprintf("INSERT into Blob_Data (blob_title, b) values ('%q', ?)", "blob");
rc = sqlite3_prepare(db_put, req, -1, &plineInfo, 0);
if (rc == SQLITE_OK && plineInfo != NULL) {
//fprintf(stderr, "SQLITE_OK\n");
sqlite3_bind_blob(plineInfo, 1, bbuf, totread, free);
sqlite3_step(plineInfo);
rc = sqlite3_finalize(plineInfo);
}
}
sqlite3_close(db_put);
/* Network zone */
init_OpenSSL ();
seed_prng ();
a = crv_cut(server, ":");
lval = strtol(a[1], &ep, 10);
if (a[1][0] == '\0' || *ep != '\0') {
fprintf(stderr, "%s\n", "Put(): Err[001] port is not a number");
return (-1);
}
if ((errno == ERANGE && (lval == LONG_MAX
|| lval == LONG_MIN)) ||
(lval > 65535 || lval < 0))
{
fprintf(stderr, "%s\n", "Put(): Err[002] port is out of range");
return (-1);
}
port = lval;
sd = crv_client_create( port, a[0], options.address_family);
/* We keep the certificate and key with the context. */
ctx = setup_client_ctx ();
/* TCP connection is ready. Do server side SSL. */
ssl = SSL_new (ctx);
if ((ssl)==NULL) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[003] Create new ssl failed");
return(-1);
}
/* connect the SSL object with a file descriptor */
code = SSL_set_fd (ssl, sd);
if ( code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[004] Put SSL on socket failed \n");
return(-1);
}
code = SSL_connect (ssl);
if (code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[005] SSL_connect() failed");
return(-1);
} else
if (code == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[006] SSL_connect() failed");
return(-1);
}
/* Build command -> GET#version#sha1#begin#end */
(void)crv_strncpy(command, "PUT#", sizeof(command));
(void)crv_strncat(command, CREUVUX_VERSION, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, sha1, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, "0", sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, size_c, sizeof(command));
/* Time initialisation */
gettimeofday (&tv1, NULL);
code = SSL_write (ssl, command, (int)strlen(command));
if ( code <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[011] SSL_write() failed.");
return(-1);
}
code = SSL_read (ssl, buf, sizeof(buf) - 1);
buf[code] = '\0';
if(!crv_strncmp (buf, "PUT_ACK"))
{
fprintf(stdout, "\n\n");
code = SSL_sendfile(ssl, sha1, filename, (off_t)0, size);
if (code == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[012] SSL_sendfile() failed");
return(-1);
}
}
code = SSL_write (ssl, "PUT_END", (int)strlen("PUT_END"));
if ( code <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[013] SSL_write() failed.");
return(-1);
}
gettimeofday (&tv2, NULL);
/* compute difference */
sec1 = tv2.tv_sec - tv1.tv_sec;
int min;
float average;
average = ((float) size / (float) sec1) / 1024;
min = sec1 / 60;
sec1 = sec1 - min * 60;
fprintf (stdout,
"\n\nFile download in %d min %d sec \nSpeed average -> %.f KBps\n\n",
min, sec1, average);
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);crv_free(sha1);
/* Send file's decription */
init_OpenSSL ();
seed_prng ();
sd = crv_client_create( port, a[0], options.address_family);
/* We keep the certificate and key with the context. */
ctx = setup_client_ctx ();
/* TCP connection is ready. Do server side SSL. */
ssl = SSL_new (ctx);
if ((ssl)==NULL) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[003] Create new ssl failed");
return(-1);
}
/* connect the SSL object with a file descriptor */
code = SSL_set_fd (ssl, sd);
if ( code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[004] Put SSL on socket failed \n");
return(-1);
}
code = SSL_connect (ssl);
if (code == 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[005] SSL_connect() failed");
return(-1);
} else
if (code == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[006] SSL_connect() failed");
return(-1);
}
size = crv_du (dbname);
if (size == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf( stderr, "%s\n", "Put(): Err[007] crv_du() can't get size");
return(-1);
}
memset(size_c, 0, sizeof(size_c));
snprintf(size_c, sizeof(size), "%lld", size);
sha1 = crv_sha1(dbname);
/* Build command -> GET#version#sha1#begin#end */
(void)crv_strncpy(command, "COMMENT#", sizeof(command));
(void)crv_strncat(command, CREUVUX_VERSION, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, sha1, sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, "0", sizeof(command));
(void)crv_strncat(command, "#", sizeof(command));
(void)crv_strncat(command, size_c, sizeof(command));
code = SSL_write (ssl, command, (int)strlen(command));
if ( code <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[011] SSL_write() failed.");
return(-1);
}
code = SSL_read (ssl, buf, sizeof(buf) - 1);
buf[code] = '\0';
if(!strncmp (buf, "PUT_ACK", strlen("PUT_ACK")))
{
code = SSL_sendfile(ssl, sha1, dbname, (off_t)0, size);
if (code == -1) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "Put() Err[012] SSL_sendfile() failed");
return(-1);
}
}
code = SSL_write (ssl, "PUT_END", (int)strlen("PUT_END"));
if ( code <= 0) {
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);
fprintf(stderr, "%s\n", "receive_get_file(): Err[013] SSL_write() failed.");
return(-1);
}
fprintf(stdout, "%s", "Information about file is uploaded\n");
/* Delete DB Meta Data */
code = unlink((const char *)dbname);
if (code == -1) {
fprintf(stderr, "%s%s\n",
"Put(): Err[010] unlink() failed with error -> ",
strerror(errno));
return (-1);
}
close(sd); SSL_free (ssl); SSL_CTX_free (ctx);crv_free(sha1);
return (0);
}
int main(void)
{
BIO *sbio;
SSL *ssl;
SSL_CTX *ctx;
int ret = 0;
SSL_library_init();
RAND_load_file("/dev/urandom", 1024);
ctx = setup_client_ctx();
/* Now doing standard connect stuff */
char sendline[MAXLINE + 1], recvline[MAXLINE + 1];
char password[MAXLINE + 1];
int sockfd;
struct sockaddr_in servaddr;
char **pptr;
//********** You can change. Put any values here *******
char *hname = "smtp.gmail.com";
//*******************************************************
char str[50];
struct hostent *hptr;
if ((hptr = gethostbyname(hname)) == NULL) {
fprintf(stderr, " gethostbyname error for host: %s: %s",
hname, hstrerror(h_errno));
exit(1);
}
printf("hostname: %s\n", hptr->h_name);
if (hptr->h_addrtype == AF_INET
&& (pptr = hptr->h_addr_list) != NULL) {
printf("address: %s\n",
inet_ntop(hptr->h_addrtype, *pptr, str,
sizeof(str)));
} else {
fprintf(stderr, "Error call inet_ntop \n");
}
sockfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(25);
inet_pton(AF_INET, str, &servaddr.sin_addr);
connect(sockfd, (SA *) & servaddr, sizeof(servaddr));
fprintf(stderr, "%s\n", socket_read(sockfd,recvline));
socket_write(sockfd,"EHLO big.mchirico.org\r\n");
fprintf(stderr, "ehlo response:%s<-\n", socket_read(sockfd,recvline));
socket_write(sockfd, "STARTTLS\r\n");
fprintf(stderr, "response to starttls:%s<-\n", socket_read(sockfd,recvline));
sbio = BIO_new_socket(sockfd, BIO_NOCLOSE);
ssl = SSL_new(ctx);
SSL_set_bio(ssl, sbio, sbio);
SSL_set_connect_state(ssl);
/* Circuit Breaker - NO encrypted connection */
if (SSL_do_handshake(ssl) == 1) {
fprintf(stderr, "SSL_do_handshake(ssl)=%d\n", 1);
} else {
fprintf(stderr, "SSL handshake error= %d\n",
SSL_get_error(ssl, ret));
fprintf(stderr,
"Cannot establish an encrypted connection\nExiting\n\n");
return -1;
}
SSL_socket_write(ssl,"EHLO mchirico.org\r\n");
fprintf(stderr,"k: %s",SSL_socket_read(ssl,recvline));
get_password("password_smtp_64", password, MAXLINE);
snprintf(sendline, MAXLINE, "AUTH PLAIN %s\r\n", password);
fprintf(stderr,"password: ->%s<-\n",password);
SSL_socket_write(ssl,sendline);
fprintf(stderr, "login res: %s<-",SSL_socket_read(ssl,recvline));
SSL_socket_write(ssl,"MAIL FROM: <*****@*****.**>\r\n");
fprintf(stderr, "2:%s",SSL_socket_read(ssl,recvline));
SSL_socket_write(ssl,"RCPT TO: <*****@*****.**>\r\n");
fprintf(stderr, "3:%s", SSL_socket_read(ssl,recvline));
SSL_socket_write(ssl,"RCPT TO: <*****@*****.**>\r\n");
fprintf(stderr, "3:%s", SSL_socket_read(ssl,recvline));
SSL_socket_write(ssl,
"DATA\r\nFrom: [email protected]\r\n"
"To: [email protected]\r\n"
"To: [email protected]\r\n"
"subject: Example using tlssmtp.c\r\n"
"\r\nTest Send from tlssmtp.c"
"\r\n.\r\n");
fprintf(stderr, "4:%s", SSL_socket_read(ssl,recvline));
fprintf(stderr, "5:%s", SSL_socket_read(ssl,recvline));
SSL_shutdown(ssl);
SSL_clear(ssl);
fprintf(stderr, "SSL Connection closed\n");
SSL_free(ssl);
SSL_CTX_free(ctx);
return 0;
}
