replace remaining log_* calls with slog_* where appropriate

diff --git a/src/client.c b/src/client.c
index 3b15b4718db74516bd89b85a96422fc607e8d6a2..89aa21ca52825b4aca53e1e7b1c8532bd54163c1 100644 (file)
--- a/src/client.c
+++ b/src/client.c
@@ -49,8 +49,7 @@ static bool check_client_passwd(PgSocket *client, const char *passwd)
        return false;
 }
 
-bool
-set_pool(PgSocket *client, const char *dbname, const char *username)
+bool set_pool(PgSocket *client, const char *dbname, const char *username)
 {
        PgDatabase *db;
        PgUser *user;
@@ -68,8 +67,8 @@ set_pool(PgSocket *client, const char *dbname, const char *username)
                user = NULL;
 
                if (db->forced_user == NULL) {
+                       slog_error(client, "auth_type=any requires forced user");
                        disconnect_client(client, true, "bouncer config error");
-                       log_error("auth_type=any requires forced user");
                        return false;
                }
                client->auth_user = db->forced_user;
@@ -191,8 +190,8 @@ static bool handle_client_startup(PgSocket *client, MBuf *pkt)
 
        switch (pkt_type) {
        case PKT_SSLREQ:
-               log_noise("C: req SSL");
-               log_noise("P: nak");
+               slog_noise(client, "C: req SSL");
+               slog_noise(client, "P: nak");
 
                /* reject SSL attempt */
                if (!sbuf_answer(&client->sbuf, "N", 1)) {
@@ -366,7 +365,7 @@ bool client_proto(SBuf *sbuf, SBufEvent evtype, MBuf *pkt, void *arg)
                break;
        case SBUF_EV_READ:
                if (mbuf_avail(pkt) < 5) {
-                       log_noise("C: got partial header, trying to wait a bit");
+                       slog_noise(client, "C: got partial header, trying to wait a bit");
                        return false;
                }
 

diff --git a/src/pooler.c b/src/pooler.c
index 37a0c65271bd2ec353adf7fac8b64d1a24178853..a8a7577fd551ed429a881801d842044dc2d47949 100644 (file)
--- a/src/pooler.c
+++ b/src/pooler.c
@@ -169,8 +169,7 @@ static void err_wait_func(int sock, short flags, void *arg)
 }
 
 /* got new connection, associate it with client struct */
-static void
-pool_accept(int sock, short flags, void *is_unix)
+static void pool_accept(int sock, short flags, void *is_unix)
 {
        int fd;
        union {
@@ -213,8 +212,7 @@ pool_accept(int sock, short flags, void *is_unix)
        }
 }
 
-bool
-use_pooler_socket(int sock, bool is_unix)
+bool use_pooler_socket(int sock, bool is_unix)
 {
        tune_socket(sock, is_unix);
 
@@ -225,8 +223,7 @@ use_pooler_socket(int sock, bool is_unix)
        return true;
 }
 
-void
-suspend_pooler(void)
+void suspend_pooler(void)
 {
        suspended = 1;
 
@@ -236,8 +233,7 @@ suspend_pooler(void)
                event_del(&ev_unix);
 }
 
-void
-resume_pooler(void)
+void resume_pooler(void)
 {
        suspended = 0;
 
@@ -253,8 +249,7 @@ resume_pooler(void)
 }
 
 /* listen on socket - should happen after all other initializations */
-void
-pooler_setup(void)
+void pooler_setup(void)
 {
        if (cf_listen_addr && !fd_net)
                fd_net = create_net_socket(cf_listen_addr, cf_listen_port);

diff --git a/src/proto.c b/src/proto.c
index 7f502479082267032e8f35a648dd0d32b86284f3..dfc22eb1111247d56931eb1e734bfb3490d8bf19 100644 (file)
--- a/src/proto.c
+++ b/src/proto.c
@@ -39,6 +39,7 @@ bool get_header(MBuf *pkt, unsigned *pkt_type_p, unsigned *pkt_len_p)
        }
        type = mbuf_get_char(pkt);
        if (type != 0) {
+               /* wire length does not include type byte */
                len = mbuf_get_uint32(pkt) + 1;
        } else {
                if (mbuf_get_char(pkt) != 0) {
@@ -143,10 +144,10 @@ bool add_welcome_parameter(PgSocket *server,
        key = mbuf_get_string(pkt);
        val = mbuf_get_string(pkt);
        if (!key || !val) {
-               log_error("broken ParameterStatus packet");
+               slog_error(server, "broken ParameterStatus packet");
                return false;
        }
-       log_debug("S: param: %s = %s", key, val);
+       slog_debug(server, "S: param: %s = %s", key, val);
        pktbuf_write_ParameterStatus(&msg, key, val);
        db->welcome_msg_len += pktbuf_written(&msg);
 
@@ -169,7 +170,7 @@ bool welcome_client(PgSocket *client)
        PktBuf msg;
        PgDatabase *db = client->pool->db;
 
-       log_noise("P: welcome_client");
+       slog_noise(client, "P: welcome_client");
        if (!db->welcome_msg_ready)
                return false;
 
@@ -184,7 +185,7 @@ bool welcome_client(PgSocket *client)
        /* send all together */
        res = pktbuf_send_immidiate(&msg, client);
        if (!res)
-               log_warning("unhandled failure to send welcome_msg");
+               slog_warning(client, "unhandled failure to send welcome_msg");
 
        return true;
 }
@@ -203,7 +204,7 @@ static bool send_password(PgSocket *server, const char *enc_psw)
 
 static bool login_clear_psw(PgSocket *server)
 {
-       log_debug("P: send clear password");
+       slog_debug(server, "P: send clear password");
        return send_password(server, server->pool->user->passwd);
 }
 
@@ -213,19 +214,18 @@ static bool login_crypt_psw(PgSocket *server, const uint8 *salt)
        const char *enc;
        PgUser *user = server->pool->user;
 
-       log_debug("P: send crypt password");
+       slog_debug(server, "P: send crypt password");
        strncpy(saltbuf, (char *)salt, 2);
        enc = crypt(user->passwd, saltbuf);
        return send_password(server, enc);
 }
 
-
 static bool login_md5_psw(PgSocket *server, const uint8 *salt)
 {
        char txt[MD5_PASSWD_LEN + 1], *src;
        PgUser *user = server->pool->user;
 
-       log_debug("P: send md5 password");
+       slog_debug(server, "P: send md5 password");
        if (!isMD5(user->passwd)) {
                pg_md5_encrypt(user->passwd, user->name, strlen(user->name), txt);
                src = txt + 3;
@@ -253,34 +253,34 @@ bool answer_authreq(PgSocket *server,
        cmd = mbuf_get_uint32(pkt);
        switch (cmd) {
        case 0:
-               log_debug("S: auth ok");
+               slog_debug(server, "S: auth ok");
                res = true;
                break;
        case 3:
-               log_debug("S: req cleartext password");
+               slog_debug(server, "S: req cleartext password");
                res = login_clear_psw(server);
                break;
        case 4:
                if (pkt_len < 5 + 4 + 2)
                        return false;
-               log_debug("S: req crypt psw");
+               slog_debug(server, "S: req crypt psw");
                salt = mbuf_get_bytes(pkt, 2);
                res = login_crypt_psw(server, salt);
                break;
        case 5:
                if (pkt_len < 5 + 4 + 4)
                        return false;
-               log_debug("S: req md5-crypted psw");
+               slog_debug(server, "S: req md5-crypted psw");
                salt = mbuf_get_bytes(pkt, 4);
                res = login_md5_psw(server, salt);
                break;
        case 2: /* kerberos */
-       case 6: /* scm something */
-               log_error("unsupported auth method: %d", cmd);
+       case 6: /* deprecated usage of SCM_RIGHTS */
+               slog_error(server, "unsupported auth method: %d", cmd);
                res = false;
                break;
        default:
-               log_error("unknown auth method: %d", cmd);
+               slog_error(server, "unknown auth method: %d", cmd);
                res = false;
                break;
        }

diff --git a/src/server.c b/src/server.c
index f3dc0426be435f13d27d4b61387bc3165e09ac48..53b881f01ef539e95cf68cc845fd5cd0066b9992 100644 (file)
--- a/src/server.c
+++ b/src/server.c
@@ -40,7 +40,7 @@ static bool handle_server_startup(PgSocket *server, MBuf *pkt)
                return false;
        }
 
-       log_noise("S: pkt '%c', len=%d", pkt_type, pkt_len);
+       slog_noise(server, "S: pkt '%c', len=%d", pkt_type, pkt_len);
 
        switch (pkt_type) {
        default:
@@ -54,7 +54,7 @@ static bool handle_server_startup(PgSocket *server, MBuf *pkt)
 
        /* packets that need closer look */
        case 'R':               /* AuthenticationXXX */
-               log_debug("calling login_answer");
+               slog_debug(server, "calling login_answer");
                res = answer_authreq(server, pkt_type, pkt_len, pkt);
                if (!res)
                        disconnect_server(server, false, "failed to answer authreq");
@@ -64,7 +64,7 @@ static bool handle_server_startup(PgSocket *server, MBuf *pkt)
                break;
        case 'Z':               /* ReadyForQuery */
                /* login ok */
-               log_debug("server login ok, start accepting queries");
+               slog_debug(server, "server login ok, start accepting queries");
                server->ready = 1;
 
                /* got all params */
@@ -179,8 +179,9 @@ static bool handle_server_work(PgSocket *server, MBuf *pkt)
                        sbuf_prepare_send(sbuf, &client->sbuf, pkt_len);
                } else {
                        if (server->state != SV_TESTED)
-                               log_warning("got packet '%c' from server"
-                                               " when not linked", pkt_type);
+                               slog_warning(server,
+                                            "got packet '%c' from server when not linked",
+                                            pkt_type);
                        sbuf_prepare_skip(sbuf, pkt_len);
                }
                break;
@@ -248,7 +249,7 @@ bool server_proto(SBuf *sbuf, SBufEvent evtype, MBuf *pkt, void *arg)
                break;
        case SBUF_EV_READ:
                if (mbuf_avail(pkt) < 5) {
-                       log_noise("S: got partial header, trying to wait a bit");
+                       slog_noise(server, "S: got partial header, trying to wait a bit");
                        return false;
                }
 
@@ -272,7 +273,7 @@ bool server_proto(SBuf *sbuf, SBufEvent evtype, MBuf *pkt, void *arg)
                disconnect_server(server, false, "connect failed");
                break;
        case SBUF_EV_CONNECT_OK:
-               log_debug("S: connect ok");
+               slog_debug(server, "S: connect ok");
                Assert(server->state == SV_LOGIN);
                server->request_time = get_cached_time();
                res = handle_connect(server);