*_alert -> alert_*

10 files changed, 33 insertions, 32 deletions

diff --git a/doc/tex/ex1.tex b/doc/tex/ex1.tex
index 87b9d72394..9c8c8f7314 100644
--- 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 ba68217f0b..b5a80b9141 100644
--- 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 8becfb9b6a..ac761ae14f 100644
--- 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 6f4a4272be..44dcb251f1 100644
--- 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 906d1ab611..a517516b60 100644
--- 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 7b695b6e59..b4e57b0935 100644
--- 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 d831b13d62..0fdff071e7 100644
--- 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 15e70423f4..0bbfd20da2 100644
--- 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 7e5e4698ea..350df43208 100644
--- 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 5da35b43c6..6051d313f2 100644
--- 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 {