*_alert -> alert_*

diff --git a/doc/tex/ex1.tex b/doc/tex/ex1.tex
index 87b9d7239434bff62a8b8607fa1062e25ee6109d..9c8c8f731429384fb333d5cb177cc266f80892db 100644 (file)
--- a/doc/tex/ex1.tex
+++ b/doc/tex/ex1.tex
@@ -144,7 +144,7 @@ int main()
          }
       } else {
          if (ret == GNUTLS_E_WARNING_ALERT_RECEIVED || ret == GNUTLS_E_FATAL_ALERT_RECEIVED)
-            printf("* Received alert [%d]\n", gnutls_get_last_alert(state));
+            printf("* Received alert [%d]\n", gnutls_alert_get_last(state));
          if (ret == GNUTLS_E_REHANDSHAKE) {
             printf("* Received HelloRequest message (server asked to rehandshake)\n");
             gnutls_send_appropriate_alert( state, ret); /* we don't want rehandshake */

diff --git a/doc/tex/ex2.tex b/doc/tex/ex2.tex
index ba68217f0bd14841da2ba9e3e3b67193847cbbd2..b5a80b91413849c21daed72552be14e11f296f30 100644 (file)
--- a/doc/tex/ex2.tex
+++ b/doc/tex/ex2.tex
@@ -116,7 +116,7 @@ int main()
       }
    } else {
       if (ret == GNUTLS_E_WARNING_ALERT_RECEIVED || ret == GNUTLS_E_FATAL_ALERT_RECEIVED)
-         printf("* Received alert [%d]\n", gnutls_get_last_alert(state));
+         printf("* Received alert [%d]\n", gnutls_alert_get_last(state));
       if (ret == GNUTLS_E_REHANDSHAKE)
          printf("* Received HelloRequest message (server asked to rehandshake)\n");
          gnutls_send_appropriate_alert( state, ret); /* we don't want rehandshake */

diff --git a/doc/tex/serv1.tex b/doc/tex/serv1.tex
index 8becfb9b6a1f5eabc7a8d41ceb77beefa24f3a8e..ac761ae14fb2ded14756214677ae4ab225c3d435 100644 (file)
--- a/doc/tex/serv1.tex
+++ b/doc/tex/serv1.tex
@@ -215,7 +215,7 @@ int main()
                          strlen(buffer));
          }
          if (ret == GNUTLS_E_WARNING_ALERT_RECEIVED || ret == GNUTLS_E_FATAL_ALERT_RECEIVED) {
-            ret = gnutls_get_last_alert(state);
+            ret = gnutls_alert_get_last(state);
             printf("* Received alert '%d'.\n", ret);
          }
       }

diff --git a/doc/tex/srp1.tex b/doc/tex/srp1.tex
index 6f4a4272bec233c5486203cca3783f960e710f8f..44dcb251f19d94bdac5da5052ba328b86dd7ffa4 100644 (file)
--- a/doc/tex/srp1.tex
+++ b/doc/tex/srp1.tex
@@ -113,7 +113,7 @@ int main()
       }
    } else {
       if (ret == GNUTLS_E_WARNING_ALERT_RECEIVED || ret == GNUTLS_E_FATAL_ALERT_RECEIVED)
-         printf("* Received alert [%d]\n", gnutls_get_last_alert(state));
+         printf("* Received alert [%d]\n", gnutls_alert_get_last(state));
       if (ret == GNUTLS_E_REHANDSHAKE)
          printf("* Received HelloRequest message (server asked to rehandshake)\n");
    }

diff --git a/lib/gnutls.h.in b/lib/gnutls.h.in
index 906d1ab611ece3f0c343e87c9b625f49145a9025..a517516b601b89c57e22bd1d658f0b01eb434322 100644 (file)
--- a/lib/gnutls.h.in
+++ b/lib/gnutls.h.in
@@ -93,9 +93,9 @@ int gnutls_check_pending(GNUTLS_STATE state);
 int gnutls_rehandshake( GNUTLS_STATE state);
 
 
-AlertDescription gnutls_get_last_alert( GNUTLS_STATE state);
-int             gnutls_send_alert(GNUTLS_SOCKET_PTR, GNUTLS_STATE, AlertLevel, AlertDescription);
-int             gnutls_send_appropriate_alert(  GNUTLS_STATE state, int err);
+AlertDescription gnutls_alert_get_last( GNUTLS_STATE state);
+int             gnutls_alert_send(GNUTLS_SOCKET_PTR, GNUTLS_STATE, AlertLevel, AlertDescription);
+int             gnutls_alert_send_appropriate(  GNUTLS_STATE state, int err);
 
 /* get information on the current state */
 BulkCipherAlgorithm gnutls_cipher_get_algo( GNUTLS_STATE state);

diff --git a/lib/gnutls_kx.c b/lib/gnutls_kx.c
index 7b695b6e5904c314d9690b9ffebccc76ff0d3674..b4e57b09356594ab5c9d01258aed40ee18ac870a 100644 (file)
--- a/lib/gnutls_kx.c
+++ b/lib/gnutls_kx.c
@@ -526,7 +526,7 @@ int _gnutls_recv_client_certificate( GNUTLS_STATE state)
                if (ret < 0) {
                        if (optional == OPTIONAL_PACKET &&
                                ret==GNUTLS_E_WARNING_ALERT_RECEIVED && 
-                               gnutls_get_last_alert(state)==GNUTLS_A_NETSCAPE_NO_CLIENT_CERTIFICATE) {
+                               gnutls_alert_get_last(state)==GNUTLS_A_NETSCAPE_NO_CLIENT_CERTIFICATE) {
 
                                /* netscape does not send an empty certificate,
                                 * but this alert. So we just ignore it.

diff --git a/lib/gnutls_record.c b/lib/gnutls_record.c
index d831b13d6278fad40f71a51ccd069ba7838d0bae..0fdff071e778d9de3de21482ae16660ce9101710 100644 (file)
--- a/lib/gnutls_record.c
+++ b/lib/gnutls_record.c
@@ -387,7 +387,7 @@ int gnutls_PRF( opaque * secret, int secret_size, uint8 * label, int label_size,
 }
 
 /**
-  * gnutls_send_alert - This function sends an alert message to the peer
+  * gnutls_alert_send - This function sends an alert message to the peer
   * @state: is a &GNUTLS_STATE structure.
   * @level: is the level of the alert
   * @desc: is the alert description
@@ -399,7 +399,7 @@ int gnutls_PRF( opaque * secret, int secret_size, uint8 * label, int label_size,
   * Returns 0 on success.
   *
   **/
-int gnutls_send_alert( GNUTLS_STATE state, AlertLevel level, AlertDescription desc)
+int gnutls_alert_send( GNUTLS_STATE state, AlertLevel level, AlertDescription desc)
 {
        uint8 data[2];
        int ret;
@@ -421,7 +421,7 @@ int gnutls_send_alert( GNUTLS_STATE state, AlertLevel level, AlertDescription de
  * on the error message.
  */
 /**
-  * gnutls_send_appropriate_alert - This function sends an alert to the peer depending on the error code
+  * gnutls_alert_send_appropriate - This function sends an alert to the peer depending on the error code
   * @state: is a &GNUTLS_STATE structure.
   * @err: is an integer
   *
@@ -437,39 +437,39 @@ int gnutls_send_alert( GNUTLS_STATE state, AlertLevel level, AlertDescription de
   * been sent to the peer.
   *
   **/
-int gnutls_send_appropriate_alert( GNUTLS_STATE state, int err) {
+int gnutls_alert_send_appropriate( GNUTLS_STATE state, int err) {
 int ret = GNUTLS_E_UNIMPLEMENTED_FEATURE;
        switch (err) { /* send appropriate alert */
                case GNUTLS_E_MAC_FAILED:
-                       ret = gnutls_send_alert( state, GNUTLS_AL_FATAL, GNUTLS_A_BAD_RECORD_MAC);
+                       ret = gnutls_alert_send( state, GNUTLS_AL_FATAL, GNUTLS_A_BAD_RECORD_MAC);
                        break;
                case GNUTLS_E_DECRYPTION_FAILED:
-                       ret = gnutls_send_alert( state, GNUTLS_AL_FATAL, GNUTLS_A_DECRYPTION_FAILED);
+                       ret = gnutls_alert_send( state, GNUTLS_AL_FATAL, GNUTLS_A_DECRYPTION_FAILED);
                        break;
                case GNUTLS_E_DECOMPRESSION_FAILED:
-                       ret = gnutls_send_alert( state, GNUTLS_AL_FATAL, GNUTLS_A_DECOMPRESSION_FAILURE);
+                       ret = gnutls_alert_send( state, GNUTLS_AL_FATAL, GNUTLS_A_DECOMPRESSION_FAILURE);
                        break;
                case GNUTLS_E_ILLEGAL_PARAMETER:
-                        ret = gnutls_send_alert( state, GNUTLS_AL_FATAL, GNUTLS_A_ILLEGAL_PARAMETER);
+                        ret = gnutls_alert_send( state, GNUTLS_AL_FATAL, GNUTLS_A_ILLEGAL_PARAMETER);
                         break;
                case GNUTLS_E_ASN1_PARSING_ERROR:
                case GNUTLS_E_NO_CERTIFICATE_FOUND:
-                        ret = gnutls_send_alert( state, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
+                        ret = gnutls_alert_send( state, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
                         break;
                case GNUTLS_E_UNKNOWN_CIPHER_SUITE:
-                        ret = gnutls_send_alert( state, GNUTLS_AL_FATAL, GNUTLS_A_HANDSHAKE_FAILURE);
+                        ret = gnutls_alert_send( state, GNUTLS_AL_FATAL, GNUTLS_A_HANDSHAKE_FAILURE);
                         break;
                case GNUTLS_E_UNEXPECTED_PACKET:
-                        ret = gnutls_send_alert( state, GNUTLS_AL_FATAL, GNUTLS_A_UNEXPECTED_MESSAGE);
+                        ret = gnutls_alert_send( state, GNUTLS_AL_FATAL, GNUTLS_A_UNEXPECTED_MESSAGE);
                         break;
                case GNUTLS_E_REHANDSHAKE:
-                        ret = gnutls_send_alert( state, GNUTLS_AL_WARNING, GNUTLS_A_NO_RENEGOTIATION);
+                        ret = gnutls_alert_send( state, GNUTLS_AL_WARNING, GNUTLS_A_NO_RENEGOTIATION);
                         break;
                case GNUTLS_E_UNSUPPORTED_VERSION_PACKET:
-                        ret = gnutls_send_alert( state, GNUTLS_AL_WARNING, GNUTLS_A_PROTOCOL_VERSION);
+                        ret = gnutls_alert_send( state, GNUTLS_AL_WARNING, GNUTLS_A_PROTOCOL_VERSION);
                        break;
                case GNUTLS_E_UNEXPECTED_PACKET_LENGTH:
-                       ret = gnutls_send_alert( state, GNUTLS_AL_FATAL, GNUTLS_A_RECORD_OVERFLOW);
+                       ret = gnutls_alert_send( state, GNUTLS_AL_FATAL, GNUTLS_A_RECORD_OVERFLOW);
                        break;
        }
        return ret;
@@ -508,7 +508,7 @@ int gnutls_bye( GNUTLS_STATE state, CloseRequest how)
                        if (STATE==STATE60) {
                                ret = _gnutls_write_flush( state);
                        } else {
-                               ret = gnutls_send_alert( state, GNUTLS_AL_WARNING, GNUTLS_A_CLOSE_NOTIFY);
+                               ret = gnutls_alert_send( state, GNUTLS_AL_WARNING, GNUTLS_A_CLOSE_NOTIFY);
                                STATE = STATE60;
                        }
 
@@ -1123,7 +1123,7 @@ gnutls_check_version( const char *req_version )
 }
 
 /**
-  * gnutls_get_last_alert - Returns the last alert number received.
+  * gnutls_alert_get_last - Returns the last alert number received.
   * @state: is a &GNUTLS_STATE structure.
   *
   * Returns the last alert number received. This function
@@ -1132,7 +1132,7 @@ gnutls_check_version( const char *req_version )
   * The peer may send alerts if he thinks some things were not 
   * right. Check gnutls.h for the available alert descriptions.
   **/
-AlertDescription gnutls_get_last_alert( GNUTLS_STATE state) {
+AlertDescription gnutls_alert_get_last( GNUTLS_STATE state) {
        return state->gnutls_internals.last_alert;
 }
 

diff --git a/lib/gnutls_record.h b/lib/gnutls_record.h
index 15e70423f43ef071e7b29ca5c98df87caf08550a..0bbfd20da2a03d537e39360758f85ed61e3468fa 100644 (file)
--- a/lib/gnutls_record.h
+++ b/lib/gnutls_record.h
@@ -1,4 +1,4 @@
-AlertDescription gnutls_get_last_alert( GNUTLS_STATE state);
+AlertDescription gnutls_alert_get_last( GNUTLS_STATE state);
 KXAlgorithm gnutls_kx_get_algo( GNUTLS_STATE state);
 ssize_t gnutls_send_int( GNUTLS_STATE state, ContentType type, HandshakeType htype, const void* data, size_t sizeofdata);
 ssize_t gnutls_recv_int( GNUTLS_STATE state, ContentType type, HandshakeType, char* data, size_t sizeofdata);

diff --git a/src/cli.c b/src/cli.c
index 7e5e4698ea9180464e801f0c1f87052f3425283d..350df43208139426aae38c6fa19dabbb85375c06 100644 (file)
--- a/src/cli.c
+++ b/src/cli.c
@@ -149,7 +149,8 @@ static int cert_callback( GNUTLS_STATE state, const gnutls_datum *client_certs,
 }
 
 const int protocol_priority[] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 };
-const int kx_priority[] = { GNUTLS_KX_X509PKI_RSA, GNUTLS_KX_X509PKI_DHE_RSA, GNUTLS_KX_SRP, GNUTLS_KX_ANON_DH, 0 };
+//const int kx_priority[] = { GNUTLS_KX_X509PKI_RSA, GNUTLS_KX_X509PKI_DHE_RSA, GNUTLS_KX_SRP, GNUTLS_KX_ANON_DH, 0 };
+const int kx_priority[] = { GNUTLS_KX_SRP, GNUTLS_KX_ANON_DH, 0 };
 const int cipher_priority[] = { GNUTLS_CIPHER_RIJNDAEL_CBC, GNUTLS_CIPHER_3DES_CBC, GNUTLS_CIPHER_ARCFOUR, 0};
 const int comp_priority[] = { GNUTLS_COMP_ZLIB, GNUTLS_COMP_NULL, 0 };
 const int mac_priority[] = { GNUTLS_MAC_SHA, GNUTLS_MAC_MD5, 0 };
@@ -255,7 +256,7 @@ int main(int argc, char** argv)
 
        if (ret < 0) {
                if (ret==GNUTLS_E_WARNING_ALERT_RECEIVED || ret==GNUTLS_E_FATAL_ALERT_RECEIVED)
-                       printf("*** Received alert [%d]\n", gnutls_get_last_alert(state));
+                       printf("*** Received alert [%d]\n", gnutls_alert_get_last(state));
 
                fprintf(stderr, "*** Handshake has failed\n");
                gnutls_perror(ret);
@@ -319,7 +320,7 @@ int main(int argc, char** argv)
 
        if (ret < 0) {
                if (ret==GNUTLS_E_WARNING_ALERT_RECEIVED || ret==GNUTLS_E_FATAL_ALERT_RECEIVED)
-                       printf("*** Received alert [%d]\n", gnutls_get_last_alert(state));
+                       printf("*** Received alert [%d]\n", gnutls_alert_get_last(state));
                fprintf(stderr, "*** Handshake failed\n");
                gnutls_perror(ret);
                gnutls_deinit(state);
@@ -374,7 +375,7 @@ int main(int argc, char** argv)
                                }
                        } else {
                                if (ret==GNUTLS_E_WARNING_ALERT_RECEIVED || ret==GNUTLS_E_FATAL_ALERT_RECEIVED)
-                                       printf("* Received alert [%d]\n", gnutls_get_last_alert(state));
+                                       printf("* Received alert [%d]\n", gnutls_alert_get_last(state));
                                if (ret==GNUTLS_E_REHANDSHAKE) {
                                        do {
                                                ret = gnutls_handshake( state);

diff --git a/src/serv.c b/src/serv.c
index 5da35b43c611843737d84c733f811816fa21318e..6051d313f26f195d2d5e7c12d4950b7226a072af 100644 (file)
--- a/src/serv.c
+++ b/src/serv.c
@@ -308,7 +308,7 @@ int read_request( GNUTLS_STATE state, char *data, int data_size, int rnl)
 
 void check_alert( GNUTLS_STATE state, int ret) {
        if (ret == GNUTLS_E_WARNING_ALERT_RECEIVED || ret == GNUTLS_E_FATAL_ALERT_RECEIVED) {
-               ret = gnutls_get_last_alert(state);
+               ret = gnutls_alert_get_last(state);
                if (ret == GNUTLS_A_NO_RENEGOTIATION)
                        printf("* Received NO_RENEGOTIATION alert. Client Does not support renegotiation.\n");
                else
@@ -466,7 +466,7 @@ int main(int argc, char **argv)
                                        ret = gnutls_rehandshake( state);
                                } while( ret==GNUTLS_E_INTERRUPTED || ret==GNUTLS_E_AGAIN);
 
-                               if (gnutls_get_last_alert(state)!=GNUTLS_A_NO_RENEGOTIATION) {
+                               if (gnutls_alert_get_last(state)!=GNUTLS_A_NO_RENEGOTIATION) {
                                        printf("* Requesting rehandshake.\n");
                                        /* continue handshake proccess */
                                        do {