Phil
Thompson
-1998-05-04
+1998-07-07
Frontend/Backend Protocol
Subsequent communications are query and result packets exchanged between the
-frontend and the backend. The postmaster takes no further part in the
-communication.
+frontend and the backend. The postmaster takes no further part in ordinary
+query/result communication. (However, the postmaster is involved when the
+frontend wishes to cancel a query currently being executed by its backend.
+Further details about that appear below.)
When the frontend wishes to disconnect it sends an appropriate packet and
+
+ BackendKeyData
+
+
+ This message is issued after successful backend startup.
+ It provides secret-key data that the frontend must save
+ if it wants to be able to issue cancel requests later.
+ The frontend should not respond to this message, but should
+ continue listening for a ReadyForQuery message.
+
+
+
+
ReadyForQuery
+The ReadyForQuery message is the same one that the backend will issue after
+each query cycle. Depending on the coding needs of the frontend, it is
+reasonable to consider ReadyForQuery as starting a query cycle (and then
+BackendKeyData indicates successful conclusion of the startup phase),
+or to consider ReadyForQuery as ending the startup phase and each subsequent
+query cycle.
+
Query
If a frontend issues a listen(l) command, then the backend will send a
NotificationResponse message (not to be confused with NoticeResponse!)
-whenever a notify(l) command is executed for the same relation name.
+whenever a notify(l) command is executed for the same notification name.
Notification responses are permitted at any point in the protocol (after
- A notify(l) command has been executed for a relation for
- which a previous listen(l) command was executed. Notifications
+ A notify(l) command has been executed for a name for which
+ a previous listen(l) command was executed. Notifications
may be sent at any time.
+It may be worth pointing out that the names used in listen and notify
+commands need not have anything to do with names of relations (tables)
+in the SQL database. Notification names are simply arbitrarily chosen
+condition names.
+
Cancelling Requests in Progress
During the processing of a query, the frontend may request cancellation of the
-query by sending a single byte of OOB (out-of-band) data. The contents of the
-data byte should be zero (although the backend does not currently check this).
-If the cancellation is effective, it results in the current command being
-terminated with an error message. Note that the backend makes no specific
-reply to the cancel request itself. If the cancel request is ineffective
-(say, because it arrived after processing was complete) then it will have
-no visible effect at all. Thus, the frontend must continue with its normal
-processing of query cycle responses after issuing a cancel request.
+query by sending an appropriate request to the postmaster. The cancel request
+is not sent directly to the backend for reasons of implementation efficiency:
+we don't want to have the backend constantly checking for new input from
+the frontend during query processing. Cancel requests should be relatively
+infrequent, so we make them slightly cumbersome in order to avoid a penalty
+in the normal case.
+
+To issue a cancel request, the frontend opens a new connection to the
+postmaster and sends a CancelRequest message, rather than the StartupPacket
+message that would ordinarily be sent across a new connection. The postmaster
+will process this request and then close the connection. For security
+reasons, no direct reply is made to the cancel request message.
+
+A CancelRequest message will be ignored unless it contains the same key data
+(PID and secret key) passed to the frontend during connection startup. If the
+request matches the PID and secret key for a currently executing backend, the
+postmaster signals the backend to abort processing of the current query.
+
+The cancellation signal may or may not have any effect --- for example, if it
+arrives after the backend has finished processing the query, then it will have
+no effect. If the cancellation is effective, it results in the current
+command being terminated early with an error message.
+
+The upshot of all this is that for reasons of both security and efficiency,
+the frontend has no direct way to tell whether a cancel request has succeeded.
+It must continue to wait for the backend to respond to the query. Issuing a
+cancel simply improves the odds that the current query will finish soon,
+and improves the odds that it will fail with an error message instead of
+succeeding.
+
+Since the cancel request is sent to the postmaster and not across the
+regular frontend/backend communication link, it is possible for the cancel
+request to be issued by any process, not just the frontend whose query is
+to be canceled. This may have some benefits of flexibility in building
+multiple-process applications. It also introduces a security risk, in that
+unauthorized persons might try to cancel queries. The security risk is
+addressed by requiring a dynamically generated secret key to be supplied
+in cancel requests.
Termination
-The frontend sends a Terminate message and immediately closes the connection.
-On receipt of the message, the backend immediately closes the connection and
-terminates.
+The normal, graceful termination procedure is that the frontend sends a
+Terminate message and immediately closes the connection. On receipt of the
+message, the backend immediately closes the connection and terminates.
+
+An ungraceful termination may occur due to software failure (i.e., core dump)
+at either end. If either frontend or backend sees an unexpected closure of
+the connection, it should clean up and terminate. The frontend has the option
+of launching a new backend by recontacting the postmaster, if it doesn't want
+to terminate itself.
+
+
+
+
+
+BackendKeyData (B)
+
+
+
+
+
+
+ Byte1('K')
+
+
+ Identifies the message as cancellation key data.
+ The frontend must save these values if it wishes to be
+ able to issue CancelRequest messages later.
+
+
+
+
+
+ Int32
+
+
+ The process ID of this backend.
+
+
+
+
+
+ Int32
+
+
+ The secret key of this backend.
+
+
+
+
+
+
+
+
+
+
+
+CancelRequest (F)
+
+
+
+
+
+
+ Int32(16)
+
+
+ The size of the packet in bytes.
+
+
+
+
+
+ Int32(80877102)
+
+
+ The cancel request code. The value is chosen to contain
+ "1234" in the most significant 16 bits, and "5678" in the
+ least 16 significant bits. (To avoid confusion, this code
+ must not be the same as any protocol version number.)
+
+
+
+
+
+ Int32
+
+
+ The process ID of the target backend.
+
+
+
+
+
+ Int32
+
+
+ The secret key for the target backend.
+
+
+
+
+
+
-
-
-
-
-
-ReadyForQuery (B)
-
-
-
-
-
-
- Byte1('Z')
-
-
- Identifies the message type. ReadyForQuery is sent
- whenever the backend is ready for a new query cycle.
-
-
-
-
-
-
+
+
+
+
+
+ReadyForQuery (B)
+
+
+
+
+
+
+ Byte1('Z')
+
+
+ Identifies the message type. ReadyForQuery is sent
+ whenever the backend is ready for a new query cycle.
+
+
+
+
+
+
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.34 1998/06/27 04:53:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.35 1998/07/09 03:28:44 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
* 2.a If the process is the same as the backend process that issued
* notification (we are notifying something that we are listening),
* signal the corresponding frontend over the comm channel.
- * 2.b For all other listening processes, we send kill(2) to wake up
+ * 2.b For all other listening processes, we send kill(SIGUSR2) to wake up
* the listening backend.
- * 3. Upon receiving a kill(2) signal from another backend process notifying
- * that one of the relation that we are listening is being notified,
- * we can be in either of two following states:
+ * 3. Upon receiving a kill(SIGUSR2) signal from another backend process
+ * notifying that one of the relation that we are listening is being
+ * notified, we can be in either of two following states:
* 3.a We are sleeping, wake up and signal our frontend.
* 3.b We are in middle of another transaction, wait until the end of
* of the current transaction and signal our frontend.
* (which takes place after commit) to all listeners on this relation.
*
* 3. Async. notification results in all backends listening on relation
- * to be woken up, by a process signal kill(2), with name of relation
+ * to be woken up, by a process signal kill(SIGUSR2), with name of relation
* passed in shared memory.
*
* 4. Each backend notifies its respective frontend over the comm
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/auth.c,v 1.28 1998/06/13 04:27:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/auth.c,v 1.29 1998/07/09 03:28:45 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
#include
-static void sendAuthRequest(Port *port, AuthRequest areq, void (*handler) ());
-static void handle_done_auth(Port *port);
-static void handle_krb4_auth(Port *port);
-static void handle_krb5_auth(Port *port);
-static void handle_password_auth(Port *port);
-static void readPasswordPacket(char *arg, PacketLen len, char *pkt);
-static void pg_passwordv0_recvauth(char *arg, PacketLen len, char *pkt);
+static void sendAuthRequest(Port *port, AuthRequest areq, PacketDoneProc handler);
+static int handle_done_auth(void *arg, PacketLen len, void *pkt);
+static int handle_krb4_auth(void *arg, PacketLen len, void *pkt);
+static int handle_krb5_auth(void *arg, PacketLen len, void *pkt);
+static int handle_password_auth(void *arg, PacketLen len, void *pkt);
+static int readPasswordPacket(void *arg, PacketLen len, void *pkt);
+static int pg_passwordv0_recvauth(void *arg, PacketLen len, void *pkt);
static int checkPassword(Port *port, char *user, char *password);
static int old_be_recvauth(Port *port);
static int map_old_to_new(Port *port, UserAuth old, int status);
* Handle a v0 password packet.
*/
-static void
-pg_passwordv0_recvauth(char *arg, PacketLen len, char *pkt)
+static int
+pg_passwordv0_recvauth(void *arg, PacketLen len, void *pkt)
{
Port *port;
PasswordPacketV0 *pp;
if (map_old_to_new(port, uaPassword, status) != STATUS_OK)
auth_failed(port);
}
+
+ return (STATUS_OK); /* don't close the connection yet */
}
else
{
AuthRequest areq;
- void (*auth_handler) ();
+ PacketDoneProc auth_handler;
/* Keep the compiler quiet. */
*/
static void
-sendAuthRequest(Port *port, AuthRequest areq, void (*handler) ())
+sendAuthRequest(Port *port, AuthRequest areq, PacketDoneProc handler)
{
char *dp,
*sp;
i += 2;
}
- PacketSendSetup(&port->pktInfo, i, handler, (char *) port);
+ PacketSendSetup(&port->pktInfo, i, handler, (void *) port);
}
* Called when we have told the front end that it is authorised.
*/
-static void
-handle_done_auth(Port *port)
+static int
+handle_done_auth(void *arg, PacketLen len, void *pkt)
{
/*
* start.
*/
- return;
+ return STATUS_OK;
}
* authentication.
*/
-static void
-handle_krb4_auth(Port *port)
+static int
+handle_krb4_auth(void *arg, PacketLen len, void *pkt)
{
+ Port *port = (Port *) arg;
+
if (pg_krb4_recvauth(port) != STATUS_OK)
auth_failed(port);
else
sendAuthRequest(port, AUTH_REQ_OK, handle_done_auth);
+
+ return STATUS_OK;
}
* authentication.
*/
-static void
-handle_krb5_auth(Port *port)
+static int
+handle_krb5_auth(void *arg, PacketLen len, void *pkt)
{
+ Port *port = (Port *) arg;
+
if (pg_krb5_recvauth(port) != STATUS_OK)
auth_failed(port);
else
sendAuthRequest(port, AUTH_REQ_OK, handle_done_auth);
+
+ return STATUS_OK;
}
* authentication.
*/
-static void
-handle_password_auth(Port *port)
+static int
+handle_password_auth(void *arg, PacketLen len, void *pkt)
{
+ Port *port = (Port *) arg;
+
/* Set up the read of the password packet. */
- PacketReceiveSetup(&port->pktInfo, readPasswordPacket, (char *) port);
+ PacketReceiveSetup(&port->pktInfo, readPasswordPacket, (void *) port);
+
+ return STATUS_OK;
}
* Called when we have received the password packet.
*/
-static void
-readPasswordPacket(char *arg, PacketLen len, char *pkt)
+static int
+readPasswordPacket(void *arg, PacketLen len, void *pkt)
{
char password[sizeof(PasswordPacket) + 1];
- Port *port;
-
- port = (Port *) arg;
+ Port *port = (Port *) arg;
/* Silently truncate a password that is too big. */
auth_failed(port);
else
sendAuthRequest(port, AUTH_REQ_OK, handle_done_auth);
+
+ return (STATUS_OK); /* don't close the connection yet */
}
case STARTUP_PASSWORD_MSG:
PacketReceiveSetup(&port->pktInfo, pg_passwordv0_recvauth,
- (char *) port);
+ (void *) port);
return STATUS_OK;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/pqcomm.c,v 1.47 1998/06/27 04:53:30 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/pqcomm.c,v 1.48 1998/07/09 03:28:46 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
* pq_getinserv - initialize address from host and service name
* pq_connect - create remote input / output connection
* pq_accept - accept remote input / output connection
- * pq_async_notify - receive notification from backend.
*
* NOTES
* These functions are used by both frontend applications and
FILE *Pfout,
*Pfin;
FILE *Pfdebug; /* debugging libpq */
-int PQAsyncNotifyWaiting; /* for async. notification */
/* --------------------------------
* pq_init - open portal file descriptors
fclose(Pfout);
Pfout = NULL;
}
- PQAsyncNotifyWaiting = 0;
PQnotifies_init();
- pq_unregoob();
}
/* --------------------------------
}
}
-/* ---
- * pq_sendoob - send a string over the out-of-band channel
- * pq_recvoob - receive a string over the oob channel
- * NB: Fortunately, the out-of-band channel doesn't conflict with
- * buffered I/O because it is separate from regular com. channel.
- * ---
- */
-int
-pq_sendoob(char *msg, int len)
-{
- int fd = fileno(Pfout);
-
- return send(fd, msg, len, MSG_OOB);
-}
-
-int
-pq_recvoob(char *msgPtr, int len)
-{
- int fd = fileno(Pfout);
-
- return recv(fd, msgPtr, len, MSG_OOB);
-}
-
/* --------------------------------
* pq_getinaddr - initialize address from host and port number
* --------------------------------
return (pq_getinaddr(sin, host, ntohs(ss->s_port)));
}
-/*
- * register an out-of-band listener proc--at most one allowed.
- * This is used for receiving async. notification from the backend.
- */
-void
-pq_regoob(void (*fptr) ())
-{
- int fd = fileno(Pfout);
-
-#if defined(hpux)
- ioctl(fd, FIOSSAIOOWN, MyProcPid);
-#elif defined(sco)
- ioctl(fd, SIOCSPGRP, MyProcPid);
-#else
- fcntl(fd, F_SETOWN, MyProcPid);
-#endif /* hpux */
- pqsignal(SIGURG, fptr);
-}
-
-void
-pq_unregoob()
-{
- pqsignal(SIGURG, SIG_DFL);
-}
-
-
-void
-pq_async_notify()
-{
- char msg[20];
-
- /* int len = sizeof(msg); */
- int len = 20;
-
- if (pq_recvoob(msg, len) >= 0)
- {
- /* debugging */
- printf("received notification: %s\n", msg);
- PQAsyncNotifyWaiting = 1;
- /* PQappendNotify(msg+1); */
- }
- else
- {
- extern int errno;
-
- printf("SIGURG but no data: len = %d, err=%d\n", len, errno);
- }
-}
-
/*
* Streams -- wrapper around Unix socket system calls
*
pqdebug("%s", PQerrormsg);
return (STATUS_ERROR);
}
- bzero(&saddr, sizeof(saddr));
+ MemSet((char *) &saddr, 0, sizeof(saddr));
saddr.sa.sa_family = family;
if (family == AF_UNIX)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/Attic/pqpacket.c,v 1.15 1998/02/26 04:31:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/Attic/pqpacket.c,v 1.16 1998/07/09 03:28:46 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
* Set up a packet read for the postmaster event loop.
*/
-void PacketReceiveSetup(Packet *pkt, void (*iodone) (), char *arg)
+void PacketReceiveSetup(Packet *pkt, PacketDoneProc iodone, void *arg)
{
pkt->nrtodo = sizeof(pkt->len);
pkt->ptr = (char *) &pkt->len;
if (pkt->iodone == NULL)
return STATUS_ERROR;
- (*pkt->iodone) (pkt->arg, pkt->len - sizeof(pkt->len),
- (char *) &pkt->pkt);
+ return (*pkt->iodone) (pkt->arg, pkt->len - sizeof(pkt->len),
+ (void *) &pkt->pkt);
}
return STATUS_OK;
if (errno == EINTR)
return STATUS_OK;
- fprintf(stderr, "read() system call failed\n");
+ perror("PacketReceiveFragment: read() failed");
return STATUS_ERROR;
}
* Set up a packet write for the postmaster event loop.
*/
-void PacketSendSetup(Packet *pkt, int nbytes, void (*iodone) (), char *arg)
+void PacketSendSetup(Packet *pkt, int nbytes, PacketDoneProc iodone, void *arg)
{
+ pkt->len = (PacketLen) nbytes;
pkt->nrtodo = nbytes;
pkt->ptr = (char *) &pkt->pkt;
pkt->iodone = iodone;
if (pkt->iodone == NULL)
return STATUS_ERROR;
- (*pkt->iodone) (pkt->arg);
+ return (*pkt->iodone) (pkt->arg, pkt->len,
+ (void *) &pkt->pkt);
}
return STATUS_OK;
if (errno == EINTR)
return STATUS_OK;
- fprintf(stderr, "write() system call failed\n");
+ perror("PacketSendFragment: write() failed");
return STATUS_ERROR;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.92 1998/06/27 14:06:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.93 1998/07/09 03:28:47 scrappy Exp $
*
* NOTES
*
*/
static unsigned int random_seed = 0;
-long MyCancelKey = 0;
extern char *optarg;
extern int optind,
static void usage(const char *);
static int ServerLoop(void);
static int BackendStartup(Port *port);
-static void readStartupPacket(char *arg, PacketLen len, char *pkt);
+static int readStartupPacket(void *arg, PacketLen len, void *pkt);
+static int processCancelRequest(Port *port, PacketLen len, void *pkt);
static int initMasks(fd_set *rmask, fd_set *wmask);
static long PostmasterRandom(void);
static void RandomSalt(char *salt);
if (silentflag)
pmdaemonize();
+ /*
+ * Set up signal handlers for the postmaster process.
+ */
+
pqsignal(SIGINT, pmdie);
pqsignal(SIGCHLD, reaper);
pqsignal(SIGTTIN, SIG_IGN);
(port = ConnCreate(ServerSock_UNIX)) != NULL)
PacketReceiveSetup(&port->pktInfo,
readStartupPacket,
- (char *) port);
+ (void *) port);
if (ServerSock_INET != INVALID_SOCK &&
FD_ISSET(ServerSock_INET, &rmask) &&
(port = ConnCreate(ServerSock_INET)) != NULL)
PacketReceiveSetup(&port->pktInfo,
readStartupPacket,
- (char *) port);
+ (void *) port);
/* Build up new masks for select(). */
* Called when the startup packet has been read.
*/
-static void
-readStartupPacket(char *arg, PacketLen len, char *pkt)
+static int
+readStartupPacket(void *arg, PacketLen len, void *pkt)
{
Port *port;
StartupPacket *si;
port = (Port *) arg;
si = (StartupPacket *) pkt;
+ /* The first field is either a protocol version number or
+ * a special request code.
+ */
+
+ port->proto = ntohl(si->protoVersion);
+
+ if (port->proto == CANCEL_REQUEST_CODE)
+ return processCancelRequest(port, len, pkt);
+
+ /* Could add additional special packet types here */
+
+ /* Check we can handle the protocol the frontend is using. */
+
+ if (PG_PROTOCOL_MAJOR(port->proto) < PG_PROTOCOL_MAJOR(PG_PROTOCOL_EARLIEST) ||
+ PG_PROTOCOL_MAJOR(port->proto) > PG_PROTOCOL_MAJOR(PG_PROTOCOL_LATEST) ||
+ (PG_PROTOCOL_MAJOR(port->proto) == PG_PROTOCOL_MAJOR(PG_PROTOCOL_LATEST) &&
+ PG_PROTOCOL_MINOR(port->proto) > PG_PROTOCOL_MINOR(PG_PROTOCOL_LATEST)))
+ {
+ PacketSendError(&port->pktInfo, "Unsupported frontend protocol.");
+ return STATUS_OK; /* don't close the connection yet */
+ }
+
/*
* Get the parameters from the startup packet as C strings. The
* packet destination was cleared first so a short packet has zeros
if (port->database[0] == '\0')
StrNCpy(port->database, si->user, sizeof(port->database) - 1);
- /* Check we can handle the protocol the frontend is using. */
-
- port->proto = ntohl(si->protoVersion);
-
- if (PG_PROTOCOL_MAJOR(port->proto) < PG_PROTOCOL_MAJOR(PG_PROTOCOL_EARLIEST) ||
- PG_PROTOCOL_MAJOR(port->proto) > PG_PROTOCOL_MAJOR(PG_PROTOCOL_LATEST) ||
- (PG_PROTOCOL_MAJOR(port->proto) == PG_PROTOCOL_MAJOR(PG_PROTOCOL_LATEST) &&
- PG_PROTOCOL_MINOR(port->proto) > PG_PROTOCOL_MINOR(PG_PROTOCOL_LATEST)))
- {
- PacketSendError(&port->pktInfo, "Unsupported frontend protocol.");
- return;
- }
-
/* Check a user name was given. */
if (port->user[0] == '\0')
{
PacketSendError(&port->pktInfo,
"No Postgres username specified in startup packet.");
- return;
+ return STATUS_OK; /* don't close the connection yet */
}
/* Start the authentication itself. */
be_recvauth(port);
+
+ return STATUS_OK; /* don't close the connection yet */
+}
+
+
+/*
+ * The client has sent a cancel request packet, not a normal
+ * start-a-new-backend packet. Perform the necessary processing.
+ * Note that in any case, we return STATUS_ERROR to close the
+ * connection immediately. Nothing is sent back to the client.
+ */
+
+static int
+processCancelRequest(Port *port, PacketLen len, void *pkt)
+{
+ CancelRequestPacket *canc = (CancelRequestPacket *) pkt;
+ int backendPID;
+ long cancelAuthCode;
+ Dlelem *curr;
+ Backend *bp;
+
+ backendPID = (int) ntohl(canc->backendPID);
+ cancelAuthCode = (long) ntohl(canc->cancelAuthCode);
+
+ /* See if we have a matching backend */
+
+ for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+ {
+ bp = (Backend *) DLE_VAL(curr);
+ if (bp->pid == backendPID)
+ {
+ if (bp->cancel_key == cancelAuthCode)
+ {
+ /* Found a match; signal that backend to cancel current op */
+ if (DebugLvl)
+ fprintf(stderr, "%s: processCancelRequest: sending SIGINT to process %d\n",
+ progname, bp->pid);
+ kill(bp->pid, SIGINT);
+ }
+ else
+ {
+ /* Right PID, wrong key: no way, Jose */
+ if (DebugLvl)
+ fprintf(stderr, "%s: processCancelRequest: bad key in cancel request for process %d\n",
+ progname, bp->pid);
+ }
+ return STATUS_ERROR;
+ }
+ }
+
+ /* No matching backend */
+ if (DebugLvl)
+ fprintf(stderr, "%s: processCancelRequest: bad PID in cancel request for process %d\n",
+ progname, backendPID);
+
+ return STATUS_ERROR;
}
char dbbuf[ARGV_SIZE + 1];
int ac = 0;
int i;
+ struct timeval now;
+ struct timezone tz;
/*
* Let's clean up ourselves as the postmaster child
if (NetServer)
StreamClose(ServerSock_INET);
StreamClose(ServerSock_UNIX);
-
+
+ /*
+ * Don't want backend to be able to see the postmaster random number
+ * generator state. We have to clobber the static random_seed *and*
+ * start a new random sequence in the random() library function.
+ */
+ random_seed = 0;
+ gettimeofday(&now, &tz);
+ srandom(now.tv_usec);
+
/* Now, on to standard postgres stuff */
MyProcPid = getpid();
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.78 1998/06/27 04:53:43 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.79 1998/07/09 03:28:48 scrappy Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
/* --------------------------------
* signal handler routines used in PostgresMain()
*
- * handle_warn() is used to catch kill(getpid(),1) which
+ * handle_warn() is used to catch kill(getpid(), SIGHUP) which
* occurs when elog(ERROR) is called.
*
* quickdie() occurs when signalled by the postmaster.
}
-/* signal handler for query cancel */
+/* signal handler for query cancel signal from postmaster */
static void
QueryCancelHandler(SIGNAL_ARGS)
{
void
CancelQuery(void)
{
- char dummy;
-
- /* throw it away */
- while (pq_recvoob(&dummy, 1) > 0)
- ;
- /* QueryCancel reset in longjump after elog() call */
+ /* QueryCancel flag will be reset in main loop, which we reach by
+ * longjmp from elog().
+ */
elog(ERROR, "Query was cancelled.");
}
}
pq_init(Portfd);
whereToSendOutput = Remote;
- pq_regoob(QueryCancelHandler); /* we do it here so the backend it connected */
}
else
whereToSendOutput = Debug;
}
#endif
+ /* ----------------
+ * Set up handler for cancel-request signal, and
+ * send this backend's cancellation info to the frontend.
+ * This should not be done until we are sure startup is successful.
+ * ----------------
+ */
+
+ pqsignal(SIGINT, QueryCancelHandler);
+
+ if (whereToSendOutput == Remote &&
+ PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
+ {
+ pq_putnchar("K", 1);
+ pq_putint((int32) MyProcPid, sizeof(int32));
+ pq_putint((int32) MyCancelKey, sizeof(int32));
+ /* Need not flush since ReadyForQuery will do it. */
+ }
+
/* ----------------
* if an exception is encountered, processing resumes here
* so we abort the current transaction and start a new one.
* so that the slaves signal the master to abort the transaction
* rather than calling AbortCurrentTransaction() themselves.
*
- * Note: elog(ERROR) causes a kill(getpid(),1) to occur sending
+ * Note: elog(ERROR) causes a kill(getpid(), SIGHUP) to occur sending
* us back here.
* ----------------
*/
if (!IsUnderPostmaster)
{
puts("\nPOSTGRES backend interactive interface");
- puts("$Revision: 1.78 $ $Date: 1998/06/27 04:53:43 $");
+ puts("$Revision: 1.79 $ $Date: 1998/07/09 03:28:48 $");
}
/* ----------------
break;
default:
- elog(ERROR, "unknown frontend message was recieved");
+ elog(ERROR, "unknown frontend message was received");
}
/* ----------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/init/globals.c,v 1.23 1998/05/29 17:00:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/globals.c,v 1.24 1998/07/09 03:28:51 scrappy Exp $
*
* NOTES
* Globals used all over the place should be declared here and not
int MyProcPid;
+long MyCancelKey;
+
char *DataDir;
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/psql/Attic/psql.c,v 1.146 1998/06/16 07:29:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/Attic/psql.c,v 1.147 1998/07/09 03:28:53 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
* If interactive, we enable a SIGINT signal catcher that sends
* a cancel request to the backend.
* Note that sending the cancel directly from the signal handler
- * is safe only because the cancel is sent as an OOB message.
- * If it were inline data, then we'd risk inserting it into the
- * middle of a normal data message by doing this.
- * (It's probably not too cool to write on stderr, for that matter...
- * but for debugging purposes we'll risk that.)
+ * is safe only because PQrequestCancel is carefully written to
+ * make it so. We have to be very careful what else we do in the
+ * signal handler.
+ * Writing on stderr is potentially dangerous, if the signal interrupted
+ * some stdio operation on stderr. On Unix we can avoid trouble by using
+ * write() instead; on Windows that's probably not workable, but we can
+ * at least avoid trusting printf by using the more primitive fputs.
*/
static PGconn * cancelConn = NULL; /* connection to try cancel on */
+static void
+safe_write_stderr (const char * s)
+{
+#ifdef WIN32
+ fputs(s, stderr);
+#else
+ write(fileno(stderr), s, strlen(s));
+#endif
+}
+
static void
handle_sigint (SIGNAL_ARGS)
{
exit(1); /* accept signal if no connection */
/* Try to send cancel request */
if (PQrequestCancel(cancelConn))
- fprintf(stderr, "\nCANCEL request sent\n");
+ {
+ safe_write_stderr("\nCANCEL request sent\n");
+ }
else
{
- fprintf(stderr, "\nCannot send cancel request:\n%s\n",
- PQerrorMessage(cancelConn));
+ safe_write_stderr("\nCannot send cancel request:\n");
+ safe_write_stderr(PQerrorMessage(cancelConn));
}
}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: dbcommands.h,v 1.1 1997/11/24 05:32:51 momjian Exp $
+ * $Id: dbcommands.h,v 1.2 1998/07/09 03:28:56 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
* Originally from tmp/daemon.h. The functions declared in daemon.h does not
* exist; hence removed. -- AY 7/29/94
*/
-#define SIGKILLDAEMON1 SIGINT
-#define SIGKILLDAEMON2 SIGTERM
+#define SIGKILLDAEMON1 SIGTERM
extern void createdb(char *dbname, char *dbpath);
extern void destroydb(char *dbname);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: libpq-be.h,v 1.10 1998/02/26 04:41:49 momjian Exp $
+ * $Id: libpq-be.h,v 1.11 1998/07/09 03:29:00 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
WritingPacket
} PacketState;
+typedef int (*PacketDoneProc) (void * arg, PacketLen pktlen, void * pktdata);
+
typedef struct Packet
{
PacketState state; /* What's in progress. */
PacketLen len; /* Actual length */
int nrtodo; /* Bytes still to transfer */
char *ptr; /* Buffer pointer */
- void (*iodone) (); /* I/O complete callback */
- char *arg; /* Argument to callback */
+ PacketDoneProc iodone; /* I/O complete callback */
+ void *arg; /* Argument to callback */
- /* A union of all the different packets. */
+ /* We declare the data buffer as a union of the allowed packet types,
+ * mainly to ensure that enough space is allocated for the largest one.
+ */
union
{
/* These are incoming and have a packet length prepended. */
StartupPacket si;
+ CancelRequestPacket canc;
PasswordPacketV0 pwv0;
PasswordPacket pw;
} pkt;
extern FILE *Pfout,
*Pfin;
-extern int PQAsyncNotifyWaiting;
extern ProtocolVersion FrontendProtocol;
/*
* prototypes for functions in pqpacket.c
*/
-void PacketReceiveSetup(Packet *pkt, void (*iodone) (), char *arg);
+void PacketReceiveSetup(Packet *pkt, PacketDoneProc iodone, void *arg);
int PacketReceiveFragment(Packet *pkt, int sock);
-void PacketSendSetup(Packet *pkt, int nbytes, void (*iodone) (), char *arg);
+void PacketSendSetup(Packet *pkt, int nbytes, PacketDoneProc iodone, void *arg);
int PacketSendFragment(Packet *pkt, int sock);
void PacketSendError(Packet *pkt, char *errormsg);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: libpq.h,v 1.16 1998/06/16 07:29:41 momjian Exp $
+ * $Id: libpq.h,v 1.17 1998/07/09 03:29:01 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
*/
typedef struct PQNotifyList
{
- char relname[NAMEDATALEN]; /* name of relation containing
- * data */
+ char relname[NAMEDATALEN]; /* listen/notify name */
int be_pid; /* process id of backend */
int valid; /* has this already been handled by user. */
/* SLNode Node; */
extern void pq_putstr(char *s);
extern void pq_putnchar(char *s, int n);
extern void pq_putint(int i, int b);
-extern int pq_sendoob(char *msg, int len);
-extern int pq_recvoob(char *msgPtr, int len);
extern int pq_getinaddr(struct sockaddr_in * sin, char *host, int port);
extern int pq_getinserv(struct sockaddr_in * sin, char *host, char *serv);
pq_connect(char *dbname, char *user, char *args, char *hostName,
char *debugTty, char *execFile, short portName);
extern int StreamOpen(char *hostName, short portName, Port *port);
-extern void pq_regoob(void (*fptr) ());
-extern void pq_unregoob(void);
-extern void pq_async_notify(void);
-extern void StreamDoUnlink();
+extern void StreamDoUnlink(void);
extern int StreamServerPort(char *hostName, short portName, int *fdP);
extern int StreamConnection(int server_fd, Port *port);
extern void StreamClose(int sock);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pqcomm.h,v 1.25 1998/05/06 23:50:32 momjian Exp $
+ * $Id: pqcomm.h,v 1.26 1998/07/09 03:29:01 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
typedef ProtocolVersion MsgType;
+/* A client can also send a cancel-current-operation request to the postmaster.
+ * This is uglier than sending it directly to the client's backend, but it
+ * avoids depending on out-of-band communication facilities.
+ */
+
+/* The cancel request code must not match any protocol version number
+ * we're ever likely to use. This random choice should do.
+ */
+#define CANCEL_REQUEST_CODE PG_PROTOCOL(1234,5678)
+
+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 */
+ uint32 cancelAuthCode; /* secret key to authorize cancel */
+} CancelRequestPacket;
+
+
/* in pqcompriv.c */
int pqGetShort(int *, FILE *);
int pqGetLong(int *, FILE *);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: miscadmin.h,v 1.26 1998/06/09 17:13:06 momjian Exp $
+ * $Id: miscadmin.h,v 1.27 1998/07/09 03:28:55 scrappy Exp $
*
* NOTES
* some of the information in this file will be moved to
extern int MyProcPid;
+extern long MyCancelKey;
+
extern char OutputFileName[];
/*
#include /* For _POSIX_PATH_MAX */
#define MAXPATHLEN _POSIX_PATH_MAX
-#define SIGURG SIGUSR1
#define NOFILE NOFILES_MIN
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-connect.c,v 1.72 1998/07/07 18:00:09 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-connect.c,v 1.73 1998/07/09 03:29:07 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
{
PGresult *res;
struct hostent *hp;
-
StartupPacket sp;
AuthRequest areq;
int laddrlen = sizeof(SockAddr);
int portno,
- family,
- len;
+ family;
char beresp;
int on = 1;
(char *) hp->h_addr,
hp->h_length);
conn->raddr.in.sin_port = htons((unsigned short) (portno));
- len = sizeof(struct sockaddr_in);
+ conn->raddr_len = sizeof(struct sockaddr_in);
}
#ifndef WIN32
else
- len = UNIXSOCK_PATH(conn->raddr.un, portno);
+ conn->raddr_len = UNIXSOCK_PATH(conn->raddr.un, portno);
#endif
errno, strerror(errno));
goto connect_errReturn;
}
- if (connect(conn->sock, &conn->raddr.sa, len) < 0)
+ if (connect(conn->sock, &conn->raddr.sa, conn->raddr_len) < 0)
{
(void) sprintf(conn->errorMessage,
"connectDB() failed: Is the postmaster running and accepting%s connections at '%s' on port '%s'?\n",
* A ReadyForQuery message indicates that startup is successful,
* but we might also get an Error message indicating failure.
* (Notice messages indicating nonfatal warnings are also allowed
- * by the protocol.)
+ * by the protocol, as is a BackendKeyData message.)
* Easiest way to handle this is to let PQgetResult() read the messages.
* We just have to fake it out about the state of the connection.
*/
}
}
+
+/*
+ * PQrequestCancel: attempt to request cancellation of the current operation.
+ *
+ * The return value is TRUE if the cancel request was successfully
+ * dispatched, FALSE if not (in which case errorMessage is set).
+ * Note: successful dispatch is no guarantee that there will be any effect at
+ * the backend. The application must read the operation result as usual.
+ *
+ * CAUTION: we want this routine to be safely callable from a signal handler
+ * (for example, an application might want to call it in a SIGINT handler).
+ * This means we cannot use any C library routine that might be non-reentrant.
+ * malloc/free are often non-reentrant, and anything that might call them is
+ * just as dangerous. We avoid sprintf here for that reason. Building up
+ * error messages with strcpy/strcat is tedious but should be quite safe.
+ */
+
+int
+PQrequestCancel(PGconn *conn)
+{
+ int tmpsock = -1;
+ struct {
+ uint32 packetlen;
+ CancelRequestPacket cp;
+ } crp;
+
+ /* Check we have an open connection */
+ if (!conn)
+ return FALSE;
+
+ if (conn->sock < 0)
+ {
+ strcpy(conn->errorMessage,
+ "PQrequestCancel() -- connection is not open\n");
+ return FALSE;
+ }
+
+ /*
+ * We need to open a temporary connection to the postmaster.
+ * Use the information saved by connectDB to do this with
+ * only kernel calls.
+ */
+ if ((tmpsock = socket(conn->raddr.sa.sa_family, SOCK_STREAM, 0)) < 0)
+ {
+ strcpy(conn->errorMessage, "PQrequestCancel() -- socket() failed: ");
+ goto cancel_errReturn;
+ }
+ if (connect(tmpsock, &conn->raddr.sa, conn->raddr_len) < 0)
+ {
+ strcpy(conn->errorMessage, "PQrequestCancel() -- connect() failed: ");
+ goto cancel_errReturn;
+ }
+ /*
+ * We needn't set nonblocking I/O or NODELAY options here.
+ */
+
+ /* Create and send the cancel request packet. */
+
+ crp.packetlen = htonl((uint32) sizeof(crp));
+ crp.cp.cancelRequestCode = (MsgType) htonl(CANCEL_REQUEST_CODE);
+ crp.cp.backendPID = htonl(conn->be_pid);
+ crp.cp.cancelAuthCode = htonl(conn->be_key);
+
+ if (send(tmpsock, (char*) &crp, sizeof(crp), 0) != (int) sizeof(crp))
+ {
+ strcpy(conn->errorMessage, "PQrequestCancel() -- send() failed: ");
+ goto cancel_errReturn;
+ }
+
+ /* Sent it, done */
+#ifdef WIN32
+ closesocket(tmpsock);
+#else
+ close(tmpsock);
+#endif
+
+ return TRUE;
+
+cancel_errReturn:
+ strcat(conn->errorMessage, strerror(errno));
+ strcat(conn->errorMessage, "\n");
+ if (tmpsock >= 0)
+ {
+#ifdef WIN32
+ closesocket(tmpsock);
+#else
+ close(tmpsock);
+#endif
+ }
+ return FALSE;
+}
+
+
/*
* PacketSend() -- send a single-packet message.
* this is like PacketSend(), defined in backend/libpq/pqpacket.c
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-exec.c,v 1.55 1998/07/03 04:24:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-exec.c,v 1.56 1998/07/09 03:29:08 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
PGRES_EMPTY_QUERY);
conn->asyncStatus = PGASYNC_READY;
break;
+ case 'K': /* secret key data from the backend */
+ /* This is expected only during backend startup,
+ * but it's just as easy to handle it as part of the
+ * main loop. Save the data and continue processing.
+ */
+ if (pqGetInt(&(conn->be_pid), 4, conn))
+ return;
+ if (pqGetInt(&(conn->be_key), 4, conn))
+ return;
+ break;
case 'N': /* notices from the backend */
if (getNotice(conn))
return;
}
-/*
- * Attempt to request cancellation of the current operation.
- *
- * The return value is TRUE if the cancel request was successfully
- * dispatched, FALSE if not (in which case errorMessage is set).
- * Note: successful dispatch is no guarantee that there will be any effect at
- * the backend. The application must read the operation result as usual.
- */
-
-int
-PQrequestCancel(PGconn *conn)
-{
- char msg[1];
-
- if (!conn)
- return FALSE;
-
- if (conn->sock < 0)
- {
- sprintf(conn->errorMessage,
- "PQrequestCancel() -- connection is not open\n");
- return FALSE;
- }
-
- msg[0] = '\0';
-
- if (send(conn->sock, msg, 1, MSG_OOB) < 0)
- {
- sprintf(conn->errorMessage,
- "PQrequestCancel() -- couldn't send OOB data: errno=%d\n%s\n",
- errno, strerror(errno));
- return FALSE;
- }
-
- return TRUE;
-}
-
-
/*
* Attempt to read a Notice response message.
* This is possible in several places, so we break it out as a subroutine.
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: libpq-fe.h,v 1.30 1998/06/16 07:29:49 momjian Exp $
+ * $Id: libpq-fe.h,v 1.31 1998/07/09 03:29:09 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
int sock; /* Unix FD for socket, -1 if not connected */
SockAddr laddr; /* Local address */
SockAddr raddr; /* Remote address */
+ int raddr_len; /* Length of remote address */
/* Miscellaneous stuff */
+ int be_pid; /* PID of backend --- needed for cancels */
+ int be_key; /* key of backend --- needed for cancels */
char salt[2]; /* password salt received from backend */
PGlobjfuncs *lobjfuncs; /* private state for large-object access fns */
#define PQsetdb(M_PGHOST,M_PGPORT,M_PGOPT,M_PGTTY,M_DBNAME) PQsetdbLogin(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME, NULL, NULL)
/* close the current connection and free the PGconn data structure */
extern void PQfinish(PGconn *conn);
+ /* issue a cancel request */
+ extern int PQrequestCancel(PGconn *conn);
/*
* close the current connection and restablish a new one with the same
/* Routines for managing an asychronous query */
extern int PQisBusy(PGconn *conn);
extern void PQconsumeInput(PGconn *conn);
- extern int PQrequestCancel(PGconn *conn);
/* Routines for copy in/out */
extern int PQgetline(PGconn *conn, char *string, int length);
extern void PQputline(PGconn *conn, const char *string);
.\" This is -*-nroff-*-
.\" XXX standard disclaimer belongs here....
-.\" $Header: /cvsroot/pgsql/src/man/Attic/listen.l,v 1.6 1998/06/24 13:21:27 momjian Exp $
+.\" $Header: /cvsroot/pgsql/src/man/Attic/listen.l,v 1.7 1998/07/09 03:29:09 scrappy Exp $
.TH "LISTEN" SQL 03/12/94 PostgreSQL PostgreSQL
.SH NAME
listen - listen for notification on a relation
.PP
This event notification is performed through the Libpq protocol
and frontend application interface. The application program
-must explicitly poll a Libpq global variable,
-.IR PQAsyncNotifyWaiting ,
-and call the routine
+must call the routine
.IR PQnotifies
in order to find out the name of the class to which a given
notification corresponds. If this code is not included in
.\" This is -*-nroff-*-
.\" XXX standard disclaimer belongs here....
-.\" $Header: /cvsroot/pgsql/src/man/Attic/notify.l,v 1.4 1998/06/24 13:21:27 momjian Exp $
+.\" $Header: /cvsroot/pgsql/src/man/Attic/notify.l,v 1.5 1998/07/09 03:29:11 scrappy Exp $
.TH "NOTIFY" SQL 11/05/95 PostgreSQL PostgreSQL
.SH NAME
notify - signal all frontends and backends listening on a class
.IR class_name
in some application-specific way.
.PP
+In fact,
+.IR class_name
+need not be the name of an SQL class at all. It is best thought of
+as a condition name that the application programmer selects.
+.PP
This event notification is performed through the Libpq protocol
and frontend application interface. The application program
-must explicitly poll a Libpq global variable,
-.IR PQAsyncNotifyWaiting ,
-and call the routine
+must call the routine
.IR PQnotifies
in order to find out the name of the class to which a given
notification corresponds. If this code is not included in
projects / postgresql.git / commitdiff