error messages revised

diff --git a/emi.canl.canl-c/src/canl.c b/emi.canl.canl-c/src/canl.c
index b404ad5..6a5ec74 100644 (file)
--- a/emi.canl.canl-c/src/canl.c
+++ b/emi.canl.canl-c/src/canl.c
@@ -78,11 +78,9 @@ canl_io_handler canl_create_io_handler(canl_ctx cc)
 
 end:
     if (err) {
-        update_error(g_cc,"cannot create canl_io_handler"
-                "canl_create_io_handler");
+        update_error(g_cc,"cannot create canl_io_handler");
         if ((err = canl_io_destroy(cc, (canl_io_handler)new_io_h)))
-            update_error(g_cc, "cannot destroy canl_ctx"
-                    "canl_create_io_handler");
+            update_error(g_cc, "cannot destroy canl_ctx");
         new_io_h = NULL;
     }
     return new_io_h;
@@ -125,8 +123,7 @@ static int init_io_content(glb_ctx *cc, io_handler *io)
 
 end:
     if (err)
-        update_error(cc, "failed to initialize io_handler"
-                "(init_io_content)");
+        update_error(cc, "failed to initialize io_handler");
     return err;
 }
 
@@ -336,8 +333,7 @@ int canl_io_close(canl_ctx cc, canl_io_handler io)
 
     if (!io) {
         err = EINVAL;
-        set_error(glb_cc, err, posix_error,  "invalid io handler"
-                " canl_io_close)");
+        set_error(glb_cc, err, posix_error,  "invalid io handler");
         return err;
     }
 
@@ -352,7 +348,6 @@ static void io_destroy(glb_ctx *cc, io_handler *io)
     io_handler *io_cc = (io_handler*) io;
     glb_ctx *glb_cc = (glb_ctx*) cc;
     int err = 0;
-
     // delete io_handler content
     if (io_cc->ar) {
         if (io_cc->ar->ent)
@@ -380,8 +375,7 @@ static void io_destroy(glb_ctx *cc, io_handler *io)
             /* TODO check it?
             if (!err) {
                 ssl_err = ERR_peek_error();
-                set_error(io_cc, err, ssl_error, "cannot free BIO"
-                       " (io_destroy)");
+                set_error(io_cc, err, ssl_error, "cannot free BIO");
                 err = 1;
             } */
             io_cc->s_ctx->bio_conn = NULL;
@@ -403,8 +397,7 @@ int canl_io_destroy(canl_ctx cc, canl_io_handler io)
 
     if (!io_cc) {
         err = EINVAL;
-        set_error(glb_cc, err, posix_error,  "invalid io handler"
-                " canl_io_destroy)");
+        set_error(glb_cc, err, posix_error,  "invalid io handler");
         return err;
     }
 
@@ -463,7 +456,7 @@ size_t canl_io_write(canl_ctx cc, canl_io_handler io, void *buffer, size_t size,
     }
 
     if (!buffer || !size) {
-       set_error(cc, EINVAL, posix_error, "No memory to write into");
+       set_error(cc, EINVAL, posix_error, "No memory to read from");
        return -1;
     }
 
@@ -483,15 +476,13 @@ int canl_set_ctx_own_cert(canl_ctx cc, canl_x509 cert,
     if (!cc)
         return EINVAL;
     if(!cert) {
-        set_error(glb_cc, EINVAL, posix_error, "invalid parameter value"
-               " (canl_set_ctx_own_cert)");
+        set_error(glb_cc, EINVAL, posix_error, "invalid parameter value");
         return err;
     }
 
     err = do_set_ctx_own_cert(glb_cc, cert, chain, key);
     if(err) {
-        update_error(glb_cc, "can't set cert or key to context"
-                " (canl_set_ctx_own_cert)");
+        update_error(glb_cc, "can't set cert or key to context");
     }
         return err;
 }
@@ -506,15 +497,13 @@ int canl_set_ctx_own_cert_file(canl_ctx cc, char *cert, char *key,
     if (!cc)
         return EINVAL;
     if(!cert ) {
-        set_error(glb_cc, EINVAL, posix_error, "invalid parameter value"
-               " (canl_set_ctx_own_cert_file)");
+        set_error(glb_cc, EINVAL, posix_error, "invalid parameter value");
         return EINVAL;
     }
 
     err = do_set_ctx_own_cert_file(glb_cc, cert, key);
     if(err) {
-        update_error(glb_cc, "can't set cert or key to context"
-                " (canl_set_ctx_own_cert_file)");
+        update_error(glb_cc, "can't set cert or key to context");
     }
         return err;
 }

diff --git a/emi.canl.canl-c/src/canl_cert.c b/emi.canl.canl-c/src/canl_cert.c
index 6cc9ac4..503b56d 100644 (file)
--- a/emi.canl.canl-c/src/canl_cert.c
+++ b/emi.canl.canl-c/src/canl_cert.c
@@ -50,7 +50,7 @@ static int set_cert(glb_ctx *cc, X509 *cert)
 
 end:
     if (err)
-        set_error(cc, err, err_orig, "cannot get certificate (set_cert)");
+        set_error(cc, err, err_orig, "cannot get certificate");
     return err;
 }
 
@@ -84,7 +84,7 @@ static int set_key_file(glb_ctx *cc, char *key)
         if (!cc->cert_key) {
             err = ENOMEM;
             set_error(cc, err, posix_error, "not enought memory for the"
-                    " certificate storage (set_key_file)");
+                    " certificate storage"); 
             return ENOMEM;
         }
     }
@@ -96,8 +96,7 @@ static int set_key_file(glb_ctx *cc, char *key)
     key_file = fopen(key, "rb");
     if (!key_file) {
        err = errno;
-        set_error(cc, err, posix_error, "cannot open file with key"
-                " (set_key_file)");
+        set_error(cc, err, posix_error, "cannot open file with key");
         return err;
     }
 
@@ -107,14 +106,12 @@ static int set_key_file(glb_ctx *cc, char *key)
     cc->cert_key->key = PEM_read_PrivateKey(key_file, NULL, NULL, NULL);
     if (!cc->cert_key->key) {
         ssl_err = ERR_peek_error();
-        set_error(cc, ssl_err, ssl_error, "error while writing key to context"
-                " (set_key_file)");
+        set_error(cc, ssl_err, ssl_error, "error while writing key to context");
         goto end;
     }
     if (fclose(key_file)){
         err = errno;
-        set_error(cc, err, posix_error, "cannot close file with key"
-                " (set_key_file)");
+        set_error(cc, err, posix_error, "cannot close file with key");
         return errno;
     }
     return 0;
@@ -122,8 +119,7 @@ static int set_key_file(glb_ctx *cc, char *key)
 end:
     if (fclose(key_file)){
         err = errno;
-        update_error(cc, "cannot close file with key"
-                " (set_key_file)");
+        update_error(cc, "cannot close file with key");
     }
     return 1;
 }
@@ -139,7 +135,7 @@ static int set_cert_file(glb_ctx *cc, char *cert)
         if (!cc->cert_key) {
             err = ENOMEM;
             set_error(cc, err, posix_error, "not enought memory for the"
-                    " certificate storage (set_cert_file)");
+                    " certificate storage"); 
             return ENOMEM;
         }
     }
@@ -151,8 +147,7 @@ static int set_cert_file(glb_ctx *cc, char *cert)
     cert_file = fopen(cert, "rb");
     if (!cert_file) {
        err = errno;
-        set_error(cc, err, posix_error, "cannot open file with cert"
-                " (set_cert_file)");
+        set_error(cc, err, posix_error, "cannot open file with cert");
         return err;
     }
     
@@ -162,14 +157,13 @@ static int set_cert_file(glb_ctx *cc, char *cert)
     if (!cc->cert_key->cert) {
         ssl_err = ERR_get_error();
         set_error(cc, ssl_err, ssl_error, "error while writing certificate"
-                " to context (set_cert_file)");
+                " to context"); 
         goto end;
     }
 
     if (fclose(cert_file)){
         err = errno;
-        set_error(cc, err, posix_error, "cannot close file with certificate"
-                " (set_cert_file)");
+        set_error(cc, err, posix_error, "cannot close file with certificate");
         return errno;
     }
     return 0;
@@ -177,8 +171,7 @@ static int set_cert_file(glb_ctx *cc, char *cert)
 end:
     if (fclose(cert_file)){
         err = errno;
-        update_error(cc, "cannot close file with certificate"
-                " (set_cert_file)");
+        update_error(cc, "cannot close file with certificate");
     }
     return 1;
 }

diff --git a/emi.canl.canl-c/src/canl_err.c b/emi.canl.canl-c/src/canl_err.c
index fd10f4f..645b14f 100644 (file)
--- a/emi.canl.canl-c/src/canl_err.c
+++ b/emi.canl.canl-c/src/canl_err.c
@@ -61,7 +61,7 @@ int set_error (glb_ctx *cc, unsigned long err_code, CANL_ERROR_ORIGIN err_orig,
     va_list ap;
     /*check cc*/
     if (!cc) 
-        return;
+        return 1;
     /* if message already exists, delete it */
     if (cc->err_msg)
         reset_error(cc, err_code);
@@ -73,7 +73,7 @@ int set_error (glb_ctx *cc, unsigned long err_code, CANL_ERROR_ORIGIN err_orig,
 
     //0 is not error
     if (!err_code)
-       return;
+       return 0;
     return resolve_error(cc, err_code, err_orig);
 }
 
@@ -139,7 +139,7 @@ int canl_get_error(canl_ctx cc, char  **reason)
 end:
     *reason = new_error;
     if (err)
-        set_error(ctx, err, e_orig, "cannot get error message (canl_get_error)");
+        set_error(ctx, err, e_orig, "cannot get error message");
     return err;
 }
 

diff --git a/emi.canl.canl-c/src/canl_ssl.c b/emi.canl.canl-c/src/canl_ssl.c
index 280fb8a..bd8e6ca 100644 (file)
--- a/emi.canl.canl-c/src/canl_ssl.c
+++ b/emi.canl.canl-c/src/canl_ssl.c
@@ -44,8 +44,7 @@ int ssl_server_init(glb_ctx *cc, io_handler *io)
     err = SSL_CTX_set_cipher_list(cc->ssl_ctx, "ALL");
     if (!err) {
         ssl_err = ERR_get_error();
-        set_error(cc, ssl_err, e_orig, "no cipher to use"
-                " (ssl_server_init)");
+        set_error(cc, ssl_err, e_orig, "no cipher to use");
         return err;
     }
     err = 0;
@@ -79,8 +78,7 @@ int ssl_server_init(glb_ctx *cc, io_handler *io)
         }
     }
     else {
-        set_error(cc, err, unknown_error, "server key or certificate missing"
-                " (ssl_server_init)");
+        set_error(cc, err, unknown_error, "server key or certificate missing");
         return 1;
     }
     /*Make sure the key and certificate file match*/
@@ -88,7 +86,7 @@ int ssl_server_init(glb_ctx *cc, io_handler *io)
         ssl_err = ERR_get_error();
         e_orig = ssl_error;
         set_error(cc, ssl_err, e_orig, "Private key does not match"
-                " the certificate public key (ssl_server_init)");
+                " the certificate public key"); 
         return 1;
     }
     else
@@ -96,13 +94,11 @@ int ssl_server_init(glb_ctx *cc, io_handler *io)
 
 end:
     if (ssl_err) {
-        set_error(cc, ssl_err, e_orig, "cannot initialize SSL context"
-                " (ssl_server_init)");
+        set_error(cc, ssl_err, e_orig, "cannot initialize SSL context");
         return 1;
     }
     else if (err) {
-        set_error(cc, ssl_err, e_orig, "cannot initialize SSL context"
-                " (ssl_server_init)");
+        set_error(cc, ssl_err, e_orig, "cannot initialize SSL context");
         return 1;
     }
     return 0;
@@ -143,8 +139,7 @@ int ssl_client_init(glb_ctx *cc, io_handler *io)
     err = SSL_CTX_set_cipher_list(cc->ssl_ctx, "ALL");
     if (!err) {
         ssl_err = ERR_get_error();
-        set_error(cc, ssl_err, e_orig, "no cipher to use"
-                " (ssl_server_init)");
+        set_error(cc, ssl_err, e_orig, "no cipher to use");
         return err;
     }
     err = 0;
@@ -179,13 +174,11 @@ int ssl_client_init(glb_ctx *cc, io_handler *io)
 
 end:
     if (ssl_err) {
-        set_error(cc, ssl_err, e_orig, "cannot initialize SSL context"
-               " (ssl_client_init)");
+        set_error(cc, ssl_err, e_orig, "cannot initialize SSL context");
     return 1;
     }
     else if (err) {
-        set_error(cc, err, e_orig, "cannot initialize SSL context"
-               " (ssl_client_init)");
+        set_error(cc, err, e_orig, "cannot initialize SSL context");
     return 1;
     }
     return 0;
@@ -369,17 +362,16 @@ static int do_ssl_connect( glb_ctx *cc, io_handler *io, struct timeval *timeout)
             timeout->tv_sec=0;
             timeout->tv_usec=0;
             err = ETIMEDOUT; 
-            set_error (cc, err, posix_error, "Connection stuck during handshake: timeout reached (do_ssl_connect)");
+            set_error (cc, err, posix_error, "Connection stuck during"
+                  " handshake: timeout reached");
         }
         else if (ret2 < 0)
-            set_error (cc, ssl_err, e_orig, "Error during SSL handshake"
-                    " (do_ssl_connect)");
+            set_error (cc, ssl_err, e_orig, "Error during SSL handshake");
         else if (ret2 == 0)
             set_error (cc, 0, unknown_error, "Connection closed"
-                    " by the other side (do_ssl_connect)");
+                    " by the other side");
         else
-            set_error (cc, err, unknown_error, "Error during SSL handshake"
-                    " (do_ssl_connect)");
+            set_error (cc, err, unknown_error, "Error during SSL handshake");
         return 1;
     }
     return 0;
@@ -431,17 +423,13 @@ static int do_ssl_accept( glb_ctx *cc, io_handler *io, struct timeval *timeout)
             timeout->tv_usec=0;
             err = ETIMEDOUT;
             set_error (cc, err, posix_error, "Connection stuck"
-                    " during handshake: timeout reached (do_ssl_accept)");
+                    " during handshake: timeout reached"); 
         }
         else if (ret2 < 0)
-            set_error (cc, ssl_err, e_orig, "Error during SSL handshake"
-                    " (do_ssl_accept)");
-        else if (ret2 == 0)
             set_error (cc, 0, unknown_error, "connection closed by"
-                   " the other side (do_ssl_accept)");
+                   " the other side");
        else
-           set_error (cc, 0, unknown_error, "Error during SSL handshake"
-                    " (do_ssl_accept)");
+           set_error (cc, 0, unknown_error, "Error during SSL handshake");
         return 1;
     }
     return 0;
@@ -523,19 +511,18 @@ int ssl_write(glb_ctx *cc, io_handler *io, void *buffer, size_t size, struct tim
 end:
     if (err) {
         errno = err;
-        set_error (cc, err, posix_error, "Error during SSL write (ssl_write)");
+        set_error (cc, err, posix_error, "Error during SSL write"); 
         return -1;
     }
     if (touted){
        err = ETIMEDOUT;
        set_error(cc, err, posix_error, "Connection stuck during"
-               " write: timeout reached (ssl_write)");
+               " write: timeout reached"); 
        return -1;
     }
     if (ret <=0){
         err = -1;//TODO what to assign??????
-        set_error (cc, err, unknown_error, "Error during SSL write"
-               " (ssl_write)");
+        set_error (cc, err, unknown_error, "Error during SSL write");
     }
     return ret;
 }
@@ -552,7 +539,7 @@ int ssl_read(glb_ctx *cc, io_handler *io, void *buffer, size_t size, struct time
 
     if (!io->s_ctx || !io->s_ctx->ssl_io) {
         err = EINVAL;
-        set_error(cc, err, posix_error, "wrong ssl handler (ssl_read)");
+        set_error(cc, err, posix_error, "wrong ssl handler"); 
         return -1;
     }
 
@@ -585,11 +572,10 @@ int ssl_read(glb_ctx *cc, io_handler *io, void *buffer, size_t size, struct time
         err = -1; //TODO what to assign
         if (timeout != -1 && (curtime - starttime >= timeout)){
             set_error(cc, ETIMEDOUT, posix_error, "Connection stuck"
-                   " during read: timeout reached. (ssl_read)");
+                   " during read: timeout reached");
         }
         else
-            set_error(cc, err, unknown_error, "Error during SSL"
-                    " read: (ssl_read)");
+            set_error(cc, err, unknown_error, "Error during SSL read");
     }
     else
         err = ret2;
@@ -642,13 +628,13 @@ int ssl_close(glb_ctx *cc, io_handler *io)
 
     if (timeout != -1 && (curtime - starttime >= timeout)){
         set_error(cc, ETIMEDOUT, posix_error, "Connection stuck"
-                " during ssl shutdown : timeout reached. (ssl_close)");
+                " during ssl shutdown : timeout reached");
         return -1;
     }
     /* TODO set_error*/
     if (ret < 0) {
         set_error(cc, 0, unknown_error, "Error during SSL"
-                " shutdown: (ssl_close)");
+                " shutdown");
         return -1;
     }
     /* successful shutdown (uni/bi directional)*/
@@ -656,7 +642,7 @@ int ssl_close(glb_ctx *cc, io_handler *io)
         return ret2;
     else {
         set_error(cc, ssl_err, ssl_error, "Error during SSL"
-                " shutdown: (ssl_close)");
+                " shutdown");
         return -1;
     }
 }