]> git.ipfire.org Git - thirdparty/postgresql.git/commitdiff
Use 'void *' for arbitrary buffers, 'uint8 *' for byte arrays
authorHeikki Linnakangas <heikki.linnakangas@iki.fi>
Thu, 8 May 2025 19:01:25 +0000 (22:01 +0300)
committerHeikki Linnakangas <heikki.linnakangas@iki.fi>
Thu, 8 May 2025 19:01:25 +0000 (22:01 +0300)
A 'void *' argument suggests that the caller might pass an arbitrary
struct, which is appropriate for functions like libc's read/write, or
pq_sendbytes(). 'uint8 *' is more appropriate for byte arrays that
have no structure, like the cancellation keys or SCRAM tokens. Some
places used 'char *', but 'uint8 *' is better because 'char *' is
commonly used for null-terminated strings. Change code around SCRAM,
MD5 authentication, and cancellation key handling to follow these
conventions.

Discussion: https://www.postgresql.org/message-id/61be9e31-7b7d-49d5-bc11-721800d89d64@eisentraut.org

24 files changed:
contrib/dblink/dblink.c
contrib/postgres_fdw/connection.c
src/backend/libpq/auth-scram.c
src/backend/libpq/auth.c
src/backend/libpq/crypt.c
src/backend/storage/ipc/procsignal.c
src/backend/utils/init/globals.c
src/common/base64.c
src/common/md5_common.c
src/common/scram-common.c
src/include/common/base64.h
src/include/common/md5.h
src/include/common/scram-common.h
src/include/libpq/auth.h
src/include/libpq/crypt.h
src/include/libpq/pqcomm.h
src/include/miscadmin.h
src/include/storage/procsignal.h
src/interfaces/libpq/fe-auth-scram.c
src/interfaces/libpq/fe-auth.c
src/interfaces/libpq/fe-cancel.c
src/interfaces/libpq/fe-misc.c
src/interfaces/libpq/fe-protocol3.c
src/interfaces/libpq/libpq-int.h

index 1b2d72c6def34a78a84c19edd5e543e16e3130b7..98d4e3d7dac4cc969acd0b365163a3960fc69928 100644 (file)
@@ -3218,7 +3218,7 @@ appendSCRAMKeysInfo(StringInfo buf)
        len = pg_b64_enc_len(sizeof(MyProcPort->scram_ClientKey));
        /* don't forget the zero-terminator */
        client_key = palloc0(len + 1);
-       encoded_len = pg_b64_encode((const char *) MyProcPort->scram_ClientKey,
+       encoded_len = pg_b64_encode(MyProcPort->scram_ClientKey,
                                                                sizeof(MyProcPort->scram_ClientKey),
                                                                client_key, len);
        if (encoded_len < 0)
@@ -3227,7 +3227,7 @@ appendSCRAMKeysInfo(StringInfo buf)
        len = pg_b64_enc_len(sizeof(MyProcPort->scram_ServerKey));
        /* don't forget the zero-terminator */
        server_key = palloc0(len + 1);
-       encoded_len = pg_b64_encode((const char *) MyProcPort->scram_ServerKey,
+       encoded_len = pg_b64_encode(MyProcPort->scram_ServerKey,
                                                                sizeof(MyProcPort->scram_ServerKey),
                                                                server_key, len);
        if (encoded_len < 0)
index 9fa7f7e95cd1fe1e33356ba90c0ca6c3a6330530..304f3c20f835697d352dbfb91b1b11d54e6afc0a 100644 (file)
@@ -577,7 +577,7 @@ connect_pg_server(ForeignServer *server, UserMapping *user)
                        len = pg_b64_enc_len(sizeof(MyProcPort->scram_ClientKey));
                        /* don't forget the zero-terminator */
                        values[n] = palloc0(len + 1);
-                       encoded_len = pg_b64_encode((const char *) MyProcPort->scram_ClientKey,
+                       encoded_len = pg_b64_encode(MyProcPort->scram_ClientKey,
                                                                                sizeof(MyProcPort->scram_ClientKey),
                                                                                (char *) values[n], len);
                        if (encoded_len < 0)
@@ -588,7 +588,7 @@ connect_pg_server(ForeignServer *server, UserMapping *user)
                        len = pg_b64_enc_len(sizeof(MyProcPort->scram_ServerKey));
                        /* don't forget the zero-terminator */
                        values[n] = palloc0(len + 1);
-                       encoded_len = pg_b64_encode((const char *) MyProcPort->scram_ServerKey,
+                       encoded_len = pg_b64_encode(MyProcPort->scram_ServerKey,
                                                                                sizeof(MyProcPort->scram_ServerKey),
                                                                                (char *) values[n], len);
                        if (encoded_len < 0)
index 26dd241efa9b31770a1beaa3e8ccee4d71a4c426..db778405724ad2846d4cd25b4cf1f467d2eeb62d 100644 (file)
@@ -158,7 +158,7 @@ typedef struct
        /* Fields from the last message from client */
        char       *client_final_message_without_proof;
        char       *client_final_nonce;
-       char            ClientProof[SCRAM_MAX_KEY_LEN];
+       uint8           ClientProof[SCRAM_MAX_KEY_LEN];
 
        /* Fields generated in the server */
        char       *server_first_message;
@@ -186,9 +186,9 @@ static void mock_scram_secret(const char *username, pg_cryptohash_type *hash_typ
 static bool is_scram_printable(char *p);
 static char *sanitize_char(char c);
 static char *sanitize_str(const char *s);
-static char *scram_mock_salt(const char *username,
-                                                        pg_cryptohash_type hash_type,
-                                                        int key_length);
+static uint8 *scram_mock_salt(const char *username,
+                                                         pg_cryptohash_type hash_type,
+                                                         int key_length);
 
 /*
  * The number of iterations to use when generating new secrets.
@@ -484,7 +484,7 @@ pg_be_scram_build_secret(const char *password)
 {
        char       *prep_password;
        pg_saslprep_rc rc;
-       char            saltbuf[SCRAM_DEFAULT_SALT_LEN];
+       uint8           saltbuf[SCRAM_DEFAULT_SALT_LEN];
        char       *result;
        const char *errstr = NULL;
 
@@ -524,7 +524,7 @@ scram_verify_plain_password(const char *username, const char *password,
                                                        const char *secret)
 {
        char       *encoded_salt;
-       char       *salt;
+       uint8      *salt;
        int                     saltlen;
        int                     iterations;
        int                     key_length = 0;
@@ -609,9 +609,9 @@ parse_scram_secret(const char *secret, int *iterations,
        char       *storedkey_str;
        char       *serverkey_str;
        int                     decoded_len;
-       char       *decoded_salt_buf;
-       char       *decoded_stored_buf;
-       char       *decoded_server_buf;
+       uint8      *decoded_salt_buf;
+       uint8      *decoded_stored_buf;
+       uint8      *decoded_server_buf;
 
        /*
         * The secret is of form:
@@ -698,7 +698,7 @@ mock_scram_secret(const char *username, pg_cryptohash_type *hash_type,
                                  int *iterations, int *key_length, char **salt,
                                  uint8 *stored_key, uint8 *server_key)
 {
-       char       *raw_salt;
+       uint8      *raw_salt;
        char       *encoded_salt;
        int                     encoded_len;
 
@@ -1231,7 +1231,7 @@ build_server_first_message(scram_state *state)
         * For convenience, however, we don't use the whole range available,
         * rather, we generate some random bytes, and base64 encode them.
         */
-       char            raw_nonce[SCRAM_RAW_NONCE_LEN];
+       uint8           raw_nonce[SCRAM_RAW_NONCE_LEN];
        int                     encoded_len;
 
        if (!pg_strong_random(raw_nonce, SCRAM_RAW_NONCE_LEN))
@@ -1271,7 +1271,7 @@ read_client_final_message(scram_state *state, const char *input)
        char       *begin,
                           *proof;
        char       *p;
-       char       *client_proof;
+       uint8      *client_proof;
        int                     client_proof_len;
 
        begin = p = pstrdup(input);
@@ -1340,7 +1340,7 @@ read_client_final_message(scram_state *state, const char *input)
                b64_message_len = pg_b64_enc_len(cbind_input_len);
                /* don't forget the zero-terminator */
                b64_message = palloc(b64_message_len + 1);
-               b64_message_len = pg_b64_encode(cbind_input, cbind_input_len,
+               b64_message_len = pg_b64_encode((uint8 *) cbind_input, cbind_input_len,
                                                                                b64_message, b64_message_len);
                if (b64_message_len < 0)
                        elog(ERROR, "could not encode channel binding data");
@@ -1440,7 +1440,7 @@ build_server_final_message(scram_state *state)
        siglen = pg_b64_enc_len(state->key_length);
        /* don't forget the zero-terminator */
        server_signature_base64 = palloc(siglen + 1);
-       siglen = pg_b64_encode((const char *) ServerSignature,
+       siglen = pg_b64_encode(ServerSignature,
                                                   state->key_length, server_signature_base64,
                                                   siglen);
        if (siglen < 0)
@@ -1467,7 +1467,7 @@ build_server_final_message(scram_state *state)
  * hash based on the username and a cluster-level secret key.  Returns a
  * pointer to a static buffer of size SCRAM_DEFAULT_SALT_LEN, or NULL.
  */
-static char *
+static uint8 *
 scram_mock_salt(const char *username, pg_cryptohash_type hash_type,
                                int key_length)
 {
@@ -1501,5 +1501,5 @@ scram_mock_salt(const char *username, pg_cryptohash_type hash_type,
        }
        pg_cryptohash_free(ctx);
 
-       return (char *) sha_digest;
+       return sha_digest;
 }
index e18683c47e726226bcb540fd372dd1934de2636f..9f4d05ffbd4536de3ca556c5892f0ba2eb2f81a9 100644 (file)
@@ -666,7 +666,7 @@ ClientAuthentication(Port *port)
  * Send an authentication request packet to the frontend.
  */
 void
-sendAuthRequest(Port *port, AuthRequest areq, const char *extradata, int extralen)
+sendAuthRequest(Port *port, AuthRequest areq, const void *extradata, int extralen)
 {
        StringInfoData buf;
 
@@ -874,7 +874,7 @@ CheckPWChallengeAuth(Port *port, const char **logdetail)
 static int
 CheckMD5Auth(Port *port, char *shadow_pass, const char **logdetail)
 {
-       char            md5Salt[4];             /* Password salt */
+       uint8           md5Salt[4];             /* Password salt */
        char       *passwd;
        int                     result;
 
index cbb85a27cc1679cca36221c555d846dd6415d6e4..f6b641e726ec355c0ab34c8865cfe2c0a4dd52af 100644 (file)
@@ -136,7 +136,7 @@ encrypt_password(PasswordType target_type, const char *role,
                        case PASSWORD_TYPE_MD5:
                                encrypted_password = palloc(MD5_PASSWD_LEN + 1);
 
-                               if (!pg_md5_encrypt(password, role, strlen(role),
+                               if (!pg_md5_encrypt(password, (uint8 *) role, strlen(role),
                                                                        encrypted_password, &errstr))
                                        elog(ERROR, "password encryption failed: %s", errstr);
                                break;
@@ -201,7 +201,7 @@ encrypt_password(PasswordType target_type, const char *role,
 int
 md5_crypt_verify(const char *role, const char *shadow_pass,
                                 const char *client_pass,
-                                const char *md5_salt, int md5_salt_len,
+                                const uint8 *md5_salt, int md5_salt_len,
                                 const char **logdetail)
 {
        int                     retval;
@@ -284,7 +284,7 @@ plain_crypt_verify(const char *role, const char *shadow_pass,
 
                case PASSWORD_TYPE_MD5:
                        if (!pg_md5_encrypt(client_pass,
-                                                               role,
+                                                               (uint8 *) role,
                                                                strlen(role),
                                                                crypt_client_pass,
                                                                &errstr))
index 1a4cc5e5d978eefa1d2818207f9203102db3f148..ce69e26d720d22dedc371977569cac8b4a8a7ead 100644 (file)
@@ -64,7 +64,7 @@ typedef struct
 {
        pg_atomic_uint32 pss_pid;
        int                     pss_cancel_key_len; /* 0 means no cancellation is possible */
-       char            pss_cancel_key[MAX_CANCEL_KEY_LENGTH];
+       uint8           pss_cancel_key[MAX_CANCEL_KEY_LENGTH];
        volatile sig_atomic_t pss_signalFlags[NUM_PROCSIGNALS];
        slock_t         pss_mutex;              /* protects the above fields */
 
@@ -163,7 +163,7 @@ ProcSignalShmemInit(void)
  *             Register the current process in the ProcSignal array
  */
 void
-ProcSignalInit(char *cancel_key, int cancel_key_len)
+ProcSignalInit(const uint8 *cancel_key, int cancel_key_len)
 {
        ProcSignalSlot *slot;
        uint64          barrier_generation;
@@ -729,7 +729,7 @@ procsignal_sigusr1_handler(SIGNAL_ARGS)
  * fields in the ProcSignal slots.
  */
 void
-SendCancelRequest(int backendPID, char *cancel_key, int cancel_key_len)
+SendCancelRequest(int backendPID, const uint8 *cancel_key, int cancel_key_len)
 {
        Assert(backendPID != 0);
 
index 1847e7c85d3a101a9d436a0d6b2954c43612c301..92b0446b80c5c663bbc89a52f6efc3802c16d83d 100644 (file)
@@ -50,7 +50,7 @@ pg_time_t     MyStartTime;
 TimestampTz MyStartTimestamp;
 struct ClientSocket *MyClientSocket;
 struct Port *MyProcPort;
-char           MyCancelKey[MAX_CANCEL_KEY_LENGTH];
+uint8          MyCancelKey[MAX_CANCEL_KEY_LENGTH];
 int                    MyCancelKeyLength = 0;
 int                    MyPMChildSlot;
 
index 6028f4134729047e3d735a9784a854147374fb8f..240461fe1e6ab4d22c4ef4db74a44fc11efc72c8 100644 (file)
@@ -41,15 +41,15 @@ static const int8 b64lookup[128] = {
 /*
  * pg_b64_encode
  *
- * Encode into base64 the given string.  Returns the length of the encoded
- * string, and -1 in the event of an error with the result buffer zeroed
- * for safety.
+ * Encode the 'src' byte array into base64.  Returns the length of the encoded
+ * string, and -1 in the event of an error with the result buffer zeroed for
+ * safety.
  */
 int
-pg_b64_encode(const char *src, int len, char *dst, int dstlen)
+pg_b64_encode(const uint8 *src, int len, char *dst, int dstlen)
 {
        char       *p;
-       const char *s,
+       const uint8 *s,
                           *end = src + len;
        int                     pos = 2;
        uint32          buf = 0;
@@ -59,7 +59,7 @@ pg_b64_encode(const char *src, int len, char *dst, int dstlen)
 
        while (s < end)
        {
-               buf |= (unsigned char) *s << (pos << 3);
+               buf |= *s << (pos << 3);
                pos--;
                s++;
 
@@ -113,11 +113,11 @@ error:
  * buffer zeroed for safety.
  */
 int
-pg_b64_decode(const char *src, int len, char *dst, int dstlen)
+pg_b64_decode(const char *src, int len, uint8 *dst, int dstlen)
 {
        const char *srcend = src + len,
                           *s = src;
-       char       *p = dst;
+       uint8      *p = dst;
        char            c;
        int                     b = 0;
        uint32          buf = 0;
index 61e396b0bbf4aafde2b0a1e1df919240cf0b0655..057ae7a449f1ce515aa1f1e6eb0c57755d24f808 100644 (file)
@@ -105,7 +105,7 @@ pg_md5_hash(const void *buff, size_t len, char *hexsum, const char **errstr)
  * (of size MD5_DIGEST_LENGTH) rather than being converted to ASCII hex.
  */
 bool
-pg_md5_binary(const void *buff, size_t len, void *outbuf, const char **errstr)
+pg_md5_binary(const void *buff, size_t len, uint8 *outbuf, const char **errstr)
 {
        pg_cryptohash_ctx *ctx;
 
@@ -142,7 +142,7 @@ pg_md5_binary(const void *buff, size_t len, void *outbuf, const char **errstr)
  * error context.
  */
 bool
-pg_md5_encrypt(const char *passwd, const char *salt, size_t salt_len,
+pg_md5_encrypt(const char *passwd, const uint8 *salt, size_t salt_len,
                           char *buf, const char **errstr)
 {
        size_t          passwd_len = strlen(passwd);
index bfd2a340016cf22bf2d68c8d1a70a27dc63a831c..e47a6ebbaab0fb57591c8d457e526a2b85b30bd4 100644 (file)
@@ -37,7 +37,7 @@
 int
 scram_SaltedPassword(const char *password,
                                         pg_cryptohash_type hash_type, int key_length,
-                                        const char *salt, int saltlen, int iterations,
+                                        const uint8 *salt, int saltlen, int iterations,
                                         uint8 *result, const char **errstr)
 {
        int                     password_len = strlen(password);
@@ -62,7 +62,7 @@ scram_SaltedPassword(const char *password,
 
        /* First iteration */
        if (pg_hmac_init(hmac_ctx, (uint8 *) password, password_len) < 0 ||
-               pg_hmac_update(hmac_ctx, (uint8 *) salt, saltlen) < 0 ||
+               pg_hmac_update(hmac_ctx, salt, saltlen) < 0 ||
                pg_hmac_update(hmac_ctx, (uint8 *) &one, sizeof(uint32)) < 0 ||
                pg_hmac_final(hmac_ctx, Ui_prev, key_length) < 0)
        {
@@ -207,7 +207,7 @@ scram_ServerKey(const uint8 *salted_password,
  */
 char *
 scram_build_secret(pg_cryptohash_type hash_type, int key_length,
-                                  const char *salt, int saltlen, int iterations,
+                                  const uint8 *salt, int saltlen, int iterations,
                                   const char *password, const char **errstr)
 {
        uint8           salted_password[SCRAM_MAX_KEY_LEN];
@@ -290,7 +290,7 @@ scram_build_secret(pg_cryptohash_type hash_type, int key_length,
        *(p++) = '$';
 
        /* stored key */
-       encoded_result = pg_b64_encode((char *) stored_key, key_length, p,
+       encoded_result = pg_b64_encode(stored_key, key_length, p,
                                                                   encoded_stored_len);
        if (encoded_result < 0)
        {
@@ -307,7 +307,7 @@ scram_build_secret(pg_cryptohash_type hash_type, int key_length,
        *(p++) = ':';
 
        /* server key */
-       encoded_result = pg_b64_encode((char *) server_key, key_length, p,
+       encoded_result = pg_b64_encode(server_key, key_length, p,
                                                                   encoded_server_len);
        if (encoded_result < 0)
        {
index 3f74aa301f09efb4890718a74511ba8b9681b77a..66cb57b017fb94832e8f33460556e85b9a7e1af2 100644 (file)
@@ -11,8 +11,8 @@
 #define BASE64_H
 
 /* base 64 */
-pg_nodiscard extern int pg_b64_encode(const char *src, int len, char *dst, int dstlen);
-pg_nodiscard extern int pg_b64_decode(const char *src, int len, char *dst, int dstlen);
+pg_nodiscard extern int pg_b64_encode(const uint8 *src, int len, char *dst, int dstlen);
+pg_nodiscard extern int pg_b64_decode(const char *src, int len, uint8 *dst, int dstlen);
 extern int     pg_b64_enc_len(int srclen);
 extern int     pg_b64_dec_len(int srclen);
 
index 18ffd998453991ac378bb6c57477c154ba24757d..0c9ae4888f2d8f9b8db7175d40aea358e0d1e415 100644 (file)
@@ -28,9 +28,9 @@
 /* Utilities common to all the MD5 implementations, as of md5_common.c */
 extern bool pg_md5_hash(const void *buff, size_t len, char *hexsum,
                                                const char **errstr);
-extern bool pg_md5_binary(const void *buff, size_t len, void *outbuf,
+extern bool pg_md5_binary(const void *buff, size_t len, uint8 *outbuf,
                                                  const char **errstr);
-extern bool pg_md5_encrypt(const char *passwd, const char *salt,
+extern bool pg_md5_encrypt(const char *passwd, const uint8 *salt,
                                                   size_t salt_len, char *buf,
                                                   const char **errstr);
 
index 46df94ef1d4648c5e3f581b1700c2952dc247bb7..5ce055e0e274d2dd31ccce23dbdefa22958dc89d 100644 (file)
@@ -51,7 +51,7 @@
 
 extern int     scram_SaltedPassword(const char *password,
                                                                 pg_cryptohash_type hash_type, int key_length,
-                                                                const char *salt, int saltlen, int iterations,
+                                                                const uint8 *salt, int saltlen, int iterations,
                                                                 uint8 *result, const char **errstr);
 extern int     scram_H(const uint8 *input, pg_cryptohash_type hash_type,
                                        int key_length, uint8 *result,
@@ -64,7 +64,7 @@ extern int    scram_ServerKey(const uint8 *salted_password,
                                                        uint8 *result, const char **errstr);
 
 extern char *scram_build_secret(pg_cryptohash_type hash_type, int key_length,
-                                                               const char *salt, int saltlen, int iterations,
+                                                               const uint8 *salt, int saltlen, int iterations,
                                                                const char *password, const char **errstr);
 
 #endif                                                 /* SCRAM_COMMON_H */
index 25b5742068f1c24188793888728ea4c4b70eb971..cc9643cce2fd8fc5039407063e185b32856b978a 100644 (file)
@@ -37,7 +37,7 @@ extern PGDLLIMPORT bool pg_krb_caseins_users;
 extern PGDLLIMPORT bool pg_gss_accept_delegation;
 
 extern void ClientAuthentication(Port *port);
-extern void sendAuthRequest(Port *port, AuthRequest areq, const char *extradata,
+extern void sendAuthRequest(Port *port, AuthRequest areq, const void *extradata,
                                                        int extralen);
 extern void set_authn_id(Port *port, const char *id);
 
index dee477428e4088e55bb48c77009c5ac1933806c3..a1b4b36314336c0dc7161abb1fe2b5280397779c 100644 (file)
@@ -51,7 +51,7 @@ extern char *encrypt_password(PasswordType target_type, const char *role,
 extern char *get_role_password(const char *role, const char **logdetail);
 
 extern int     md5_crypt_verify(const char *role, const char *shadow_pass,
-                                                        const char *client_pass, const char *md5_salt,
+                                                        const char *client_pass, const uint8 *md5_salt,
                                                         int md5_salt_len, const char **logdetail);
 extern int     plain_crypt_verify(const char *role, const char *shadow_pass,
                                                           const char *client_pass,
index d11069cf8dc822e6ef656d752201072689207de5..f04ca13565398db9a245be897153bfff05e98ab1 100644 (file)
@@ -141,7 +141,7 @@ typedef struct CancelRequestPacket
        /* Note that each field is stored in network byte order! */
        MsgType         cancelRequestCode;      /* code to identify a cancel request */
        uint32          backendPID;             /* PID of client's backend */
-       char            cancelAuthCode[FLEXIBLE_ARRAY_MEMBER];  /* secret key to
+       uint8           cancelAuthCode[FLEXIBLE_ARRAY_MEMBER];  /* secret key to
                                                                                                                 * authorize cancel */
 } CancelRequestPacket;
 
index 629772b038102df9f593cb2ff13d7dd88c1eaee5..1e59a7f910fa858049e6296b4709c50166004b28 100644 (file)
@@ -192,7 +192,7 @@ extern PGDLLIMPORT pg_time_t MyStartTime;
 extern PGDLLIMPORT TimestampTz MyStartTimestamp;
 extern PGDLLIMPORT struct Port *MyProcPort;
 extern PGDLLIMPORT struct Latch *MyLatch;
-extern PGDLLIMPORT char MyCancelKey[];
+extern PGDLLIMPORT uint8 MyCancelKey[];
 extern PGDLLIMPORT int MyCancelKeyLength;
 extern PGDLLIMPORT int MyPMChildSlot;
 
index cfe146314452f382000809eed9938688ac32af2c..345d5a0ecb1eaf359b9e38e7ac24dbaf8a8a021c 100644 (file)
@@ -73,10 +73,10 @@ typedef enum
 extern Size ProcSignalShmemSize(void);
 extern void ProcSignalShmemInit(void);
 
-extern void ProcSignalInit(char *cancel_key, int cancel_key_len);
+extern void ProcSignalInit(const uint8 *cancel_key, int cancel_key_len);
 extern int     SendProcSignal(pid_t pid, ProcSignalReason reason,
                                                   ProcNumber procNumber);
-extern void SendCancelRequest(int backendPID, char *cancel_key, int cancel_key_len);
+extern void SendCancelRequest(int backendPID, const uint8 *cancel_key, int cancel_key_len);
 
 extern uint64 EmitProcSignalBarrier(ProcSignalBarrierType type);
 extern void WaitForProcSignalBarrier(uint64 generation);
index fe18615197f6982df2d1b759405ebfead892e4ab..f6d6a5aa977b83cd8da7001b71240152b6f92d09 100644 (file)
@@ -70,14 +70,14 @@ typedef struct
 
        /* These come from the server-first message */
        char       *server_first_message;
-       char       *salt;
+       uint8      *salt;
        int                     saltlen;
        int                     iterations;
        char       *nonce;
 
        /* These come from the server-final message */
        char       *server_final_message;
-       char            ServerSignature[SCRAM_MAX_KEY_LEN];
+       uint8           ServerSignature[SCRAM_MAX_KEY_LEN];
 } fe_scram_state;
 
 static bool read_server_first_message(fe_scram_state *state, char *input);
@@ -350,7 +350,7 @@ static char *
 build_client_first_message(fe_scram_state *state)
 {
        PGconn     *conn = state->conn;
-       char            raw_nonce[SCRAM_RAW_NONCE_LEN + 1];
+       uint8           raw_nonce[SCRAM_RAW_NONCE_LEN + 1];
        char       *result;
        int                     channel_info_len;
        int                     encoded_len;
@@ -513,7 +513,7 @@ build_client_final_message(fe_scram_state *state)
                        free(cbind_input);
                        goto oom_error;
                }
-               encoded_cbind_len = pg_b64_encode(cbind_input, cbind_input_len,
+               encoded_cbind_len = pg_b64_encode((uint8 *) cbind_input, cbind_input_len,
                                                                                  buf.data + buf.len,
                                                                                  encoded_cbind_len);
                if (encoded_cbind_len < 0)
@@ -574,7 +574,7 @@ build_client_final_message(fe_scram_state *state)
        encoded_len = pg_b64_enc_len(state->key_length);
        if (!enlargePQExpBuffer(&buf, encoded_len))
                goto oom_error;
-       encoded_len = pg_b64_encode((char *) client_proof,
+       encoded_len = pg_b64_encode(client_proof,
                                                                state->key_length,
                                                                buf.data + buf.len,
                                                                encoded_len);
@@ -694,7 +694,7 @@ read_server_final_message(fe_scram_state *state, char *input)
 {
        PGconn     *conn = state->conn;
        char       *encoded_server_signature;
-       char       *decoded_server_signature;
+       uint8      *decoded_server_signature;
        int                     server_signature_len;
 
        state->server_final_message = strdup(input);
@@ -916,7 +916,7 @@ pg_fe_scram_build_secret(const char *password, int iterations, const char **errs
 {
        char       *prep_password;
        pg_saslprep_rc rc;
-       char            saltbuf[SCRAM_DEFAULT_SALT_LEN];
+       uint8           saltbuf[SCRAM_DEFAULT_SALT_LEN];
        char       *result;
 
        /*
index ec7a9236044ec060e24ea81a9602e2c6a026a814..84a042269dec9c9c1b92b4dd8e816417ed7c20fa 100644 (file)
@@ -798,7 +798,7 @@ pg_password_sendauth(PGconn *conn, const char *password, AuthRequest areq)
        int                     ret;
        char       *crypt_pwd = NULL;
        const char *pwd_to_send;
-       char            md5Salt[4];
+       uint8           md5Salt[4];
 
        /* Read the salt from the AuthenticationMD5Password message. */
        if (areq == AUTH_REQ_MD5)
@@ -829,7 +829,7 @@ pg_password_sendauth(PGconn *conn, const char *password, AuthRequest areq)
                                }
 
                                crypt_pwd2 = crypt_pwd + MD5_PASSWD_LEN + 1;
-                               if (!pg_md5_encrypt(password, conn->pguser,
+                               if (!pg_md5_encrypt(password, (uint8 *) conn->pguser,
                                                                        strlen(conn->pguser), crypt_pwd2,
                                                                        &errstr))
                                {
@@ -1369,7 +1369,7 @@ PQencryptPassword(const char *passwd, const char *user)
        if (!crypt_pwd)
                return NULL;
 
-       if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd, &errstr))
+       if (!pg_md5_encrypt(passwd, (uint8 *) user, strlen(user), crypt_pwd, &errstr))
        {
                free(crypt_pwd);
                return NULL;
@@ -1482,7 +1482,7 @@ PQencryptPasswordConn(PGconn *conn, const char *passwd, const char *user,
                {
                        const char *errstr = NULL;
 
-                       if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd, &errstr))
+                       if (!pg_md5_encrypt(passwd, (uint8 *) user, strlen(user), crypt_pwd, &errstr))
                        {
                                libpq_append_conn_error(conn, "could not encrypt password: %s", errstr);
                                free(crypt_pwd);
index 25de2a337c98c4ea912fb86df93c152214c2bdb7..8c7c198a53071025aea869d6707e1afeaf872b94 100644 (file)
@@ -463,7 +463,7 @@ PQsendCancelRequest(PGconn *cancelConn)
        memset(&req, 0, offsetof(CancelRequestPacket, cancelAuthCode));
        req.cancelRequestCode = (MsgType) pg_hton32(CANCEL_REQUEST_CODE);
        req.backendPID = pg_hton32(cancelConn->be_pid);
-       if (pqPutnchar((char *) &req, offsetof(CancelRequestPacket, cancelAuthCode), cancelConn))
+       if (pqPutnchar(&req, offsetof(CancelRequestPacket, cancelAuthCode), cancelConn))
                return STATUS_ERROR;
        if (pqPutnchar(cancelConn->be_cancel_key, cancelConn->be_cancel_key_len, cancelConn))
                return STATUS_ERROR;
index 2648df93813c886eda7ea1f4b9d08b32790737b5..c14e3c952502d1c89a714bb5b86d1d26a08e039f 100644 (file)
@@ -67,7 +67,7 @@ PQlibVersion(void)
 
 
 /*
- * pqGetc: get 1 character from the connection
+ * pqGetc: read 1 character from the connection
  *
  *     All these routines return 0 on success, EOF on error.
  *     Note that for the Get routines, EOF only means there is not enough
@@ -100,7 +100,7 @@ pqPutc(char c, PGconn *conn)
 
 /*
  * pqGets[_append]:
- * get a null-terminated string from the connection,
+ * read a null-terminated string from the connection,
  * and store it in an expansible PQExpBuffer.
  * If we run out of memory, all of the string is still read,
  * but the excess characters are silently discarded.
@@ -159,10 +159,10 @@ pqPuts(const char *s, PGconn *conn)
 
 /*
  * pqGetnchar:
- *     get a string of exactly len bytes in buffer s, no null termination
+ *     read exactly len bytes in buffer s, no null termination
  */
 int
-pqGetnchar(char *s, size_t len, PGconn *conn)
+pqGetnchar(void *s, size_t len, PGconn *conn)
 {
        if (len > (size_t) (conn->inEnd - conn->inCursor))
                return EOF;
@@ -199,7 +199,7 @@ pqSkipnchar(size_t len, PGconn *conn)
  *     write exactly len bytes to the current message
  */
 int
-pqPutnchar(const char *s, size_t len, PGconn *conn)
+pqPutnchar(const void *s, size_t len, PGconn *conn)
 {
        if (pqPutMsgBytes(s, len, conn))
                return EOF;
index 3a1ac398fd0bf90e25f71525c55ffc96d944a738..beb1c889aad7395e892ffe941c94a445f10719b9 100644 (file)
@@ -2121,7 +2121,7 @@ pqFunctionCall3(PGconn *conn, Oid fnid,
                }
                else
                {
-                       if (pqPutnchar((char *) args[i].u.ptr, args[i].len, conn))
+                       if (pqPutnchar(args[i].u.ptr, args[i].len, conn))
                                return NULL;
                }
        }
@@ -2215,7 +2215,7 @@ pqFunctionCall3(PGconn *conn, Oid fnid,
                                        }
                                        else
                                        {
-                                               if (pqGetnchar((char *) result_buf,
+                                               if (pqGetnchar(result_buf,
                                                                           *actual_result_len,
                                                                           conn))
                                                        continue;
index 3d8a5045b989ebb669b4817718c349dba38d037f..a6cfd7f5c9d83b89a0405f43d867e3f04f229f31 100644 (file)
@@ -539,16 +539,16 @@ struct pg_conn
                                                                 * tried host */
        bool            send_appname;   /* okay to send application_name? */
        size_t          scram_client_key_len;
-       void       *scram_client_key_binary;    /* binary SCRAM client key */
+       uint8      *scram_client_key_binary;    /* binary SCRAM client key */
        size_t          scram_server_key_len;
-       void       *scram_server_key_binary;    /* binary SCRAM server key */
+       uint8      *scram_server_key_binary;    /* binary SCRAM server key */
        ProtocolVersion min_pversion;   /* protocol version to request */
        ProtocolVersion max_pversion;   /* protocol version to request */
 
        /* Miscellaneous stuff */
        int                     be_pid;                 /* PID of backend --- needed for cancels */
        int                     be_cancel_key_len;
-       char       *be_cancel_key;      /* query cancellation key and its length */
+       uint8      *be_cancel_key;      /* query cancellation key */
        pgParameterStatus *pstatus; /* ParameterStatus data */
        int                     client_encoding;        /* encoding id */
        bool            std_strings;    /* standard_conforming_strings */
@@ -787,9 +787,9 @@ extern int  pqPutc(char c, PGconn *conn);
 extern int     pqGets(PQExpBuffer buf, PGconn *conn);
 extern int     pqGets_append(PQExpBuffer buf, PGconn *conn);
 extern int     pqPuts(const char *s, PGconn *conn);
-extern int     pqGetnchar(char *s, size_t len, PGconn *conn);
+extern int     pqGetnchar(void *s, size_t len, PGconn *conn);
 extern int     pqSkipnchar(size_t len, PGconn *conn);
-extern int     pqPutnchar(const char *s, size_t len, PGconn *conn);
+extern int     pqPutnchar(const void *s, size_t len, PGconn *conn);
 extern int     pqGetInt(int *result, size_t bytes, PGconn *conn);
 extern int     pqPutInt(int value, size_t bytes, PGconn *conn);
 extern int     pqPutMsgStart(char msg_type, PGconn *conn);