PostgreSQL Source Code  git master
fe-trace.c File Reference
#include "postgres_fe.h"
#include <ctype.h>
#include <limits.h>
#include <sys/time.h>
#include <unistd.h>
#include "libpq-fe.h"
#include "libpq-int.h"
#include "port/pg_bswap.h"
Include dependency graph for fe-trace.c:

Go to the source code of this file.

Functions

void PQtrace (PGconn *conn, FILE *debug_port)
 
void PQuntrace (PGconn *conn)
 
void PQsetTraceFlags (PGconn *conn, int flags)
 
static void pqTraceFormatTimestamp (char *timestr, size_t ts_len)
 
static void pqTraceOutputByte1 (FILE *pfdebug, const char *data, int *cursor)
 
static int pqTraceOutputInt16 (FILE *pfdebug, const char *data, int *cursor)
 
static int pqTraceOutputInt32 (FILE *pfdebug, const char *data, int *cursor, bool suppress)
 
static void pqTraceOutputString (FILE *pfdebug, const char *data, int *cursor, bool suppress)
 
static void pqTraceOutputNchar (FILE *pfdebug, int len, const char *data, int *cursor)
 
static void pqTraceOutputA (FILE *f, const char *message, int *cursor, bool regress)
 
static void pqTraceOutputB (FILE *f, const char *message, int *cursor)
 
static void pqTraceOutputC (FILE *f, bool toServer, const char *message, int *cursor)
 
static void pqTraceOutputD (FILE *f, bool toServer, const char *message, int *cursor)
 
static void pqTraceOutputNR (FILE *f, const char *type, const char *message, int *cursor, bool regress)
 
static void pqTraceOutputE (FILE *f, bool toServer, const char *message, int *cursor, bool regress)
 
static void pqTraceOutputf (FILE *f, const char *message, int *cursor)
 
static void pqTraceOutputF (FILE *f, const char *message, int *cursor, bool regress)
 
static void pqTraceOutputG (FILE *f, const char *message, int *cursor)
 
static void pqTraceOutputH (FILE *f, const char *message, int *cursor)
 
static void pqTraceOutputK (FILE *f, const char *message, int *cursor, bool regress)
 
static void pqTraceOutputP (FILE *f, const char *message, int *cursor, bool regress)
 
static void pqTraceOutputQ (FILE *f, const char *message, int *cursor)
 
static void pqTraceOutputR (FILE *f, const char *message, int *cursor)
 
static void pqTraceOutputS (FILE *f, const char *message, int *cursor)
 
static void pqTraceOutputt (FILE *f, const char *message, int *cursor, bool regress)
 
static void pqTraceOutputT (FILE *f, const char *message, int *cursor, bool regress)
 
static void pqTraceOutputv (FILE *f, const char *message, int *cursor)
 
static void pqTraceOutputV (FILE *f, const char *message, int *cursor)
 
static void pqTraceOutputW (FILE *f, const char *message, int *cursor, int length)
 
static void pqTraceOutputZ (FILE *f, const char *message, int *cursor)
 
void pqTraceOutputMessage (PGconn *conn, const char *message, bool toServer)
 
void pqTraceOutputNoTypeByteMessage (PGconn *conn, const char *message)
 

Function Documentation

◆ PQsetTraceFlags()

void PQsetTraceFlags ( PGconn conn,
int  flags 
)

Definition at line 64 of file fe-trace.c.

65 {
66  if (conn == NULL)
67  return;
68  /* If PQtrace() failed, do nothing. */
69  if (conn->Pfdebug == NULL)
70  return;
71  conn->traceFlags = flags;
72 }
PGconn * conn
Definition: streamutil.c:55
FILE * Pfdebug
Definition: libpq-int.h:417
int traceFlags
Definition: libpq-int.h:418

References conn, pg_conn::Pfdebug, and pg_conn::traceFlags.

Referenced by main().

◆ PQtrace()

void PQtrace ( PGconn conn,
FILE *  debug_port 
)

Definition at line 35 of file fe-trace.c.

36 {
37  if (conn == NULL)
38  return;
39  PQuntrace(conn);
40  if (debug_port == NULL)
41  return;
42 
43  conn->Pfdebug = debug_port;
44  conn->traceFlags = 0;
45 }
void PQuntrace(PGconn *conn)
Definition: fe-trace.c:49

References conn, pg_conn::Pfdebug, PQuntrace(), and pg_conn::traceFlags.

Referenced by main().

◆ pqTraceFormatTimestamp()

static void pqTraceFormatTimestamp ( char *  timestr,
size_t  ts_len 
)
static

Definition at line 80 of file fe-trace.c.

81 {
82  struct timeval tval;
83  time_t now;
84 
85  gettimeofday(&tval, NULL);
86 
87  /*
88  * MSVC's implementation of timeval uses a long for tv_sec, however,
89  * localtime() expects a time_t pointer. Here we'll assign tv_sec to a
90  * local time_t variable so that we pass localtime() the correct pointer
91  * type.
92  */
93  now = tval.tv_sec;
94  strftime(timestr, ts_len,
95  "%Y-%m-%d %H:%M:%S",
96  localtime(&now));
97  /* append microseconds */
98  snprintf(timestr + strlen(timestr), ts_len - strlen(timestr),
99  ".%06u", (unsigned int) (tval.tv_usec));
100 }
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1618
#define snprintf
Definition: port.h:238
int gettimeofday(struct timeval *tp, void *tzp)

References gettimeofday(), now(), and snprintf.

Referenced by pqTraceOutputMessage(), and pqTraceOutputNoTypeByteMessage().

◆ pqTraceOutputA()

static void pqTraceOutputA ( FILE *  f,
const char *  message,
int *  cursor,
bool  regress 
)
static

Definition at line 220 of file fe-trace.c.

221 {
222  fprintf(f, "NotificationResponse\t");
223  pqTraceOutputInt32(f, message, cursor, regress);
224  pqTraceOutputString(f, message, cursor, false);
225  pqTraceOutputString(f, message, cursor, false);
226 }
static void pqTraceOutputString(FILE *pfdebug, const char *data, int *cursor, bool suppress)
Definition: fe-trace.c:163
static int pqTraceOutputInt32(FILE *pfdebug, const char *data, int *cursor, bool suppress)
Definition: fe-trace.c:144
#define fprintf
Definition: port.h:242
Definition: type.h:137

References fprintf, pqTraceOutputInt32(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputB()

static void pqTraceOutputB ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 230 of file fe-trace.c.

231 {
232  int nparams;
233 
234  fprintf(f, "Bind\t");
235  pqTraceOutputString(f, message, cursor, false);
236  pqTraceOutputString(f, message, cursor, false);
237  nparams = pqTraceOutputInt16(f, message, cursor);
238 
239  for (int i = 0; i < nparams; i++)
240  pqTraceOutputInt16(f, message, cursor);
241 
242  nparams = pqTraceOutputInt16(f, message, cursor);
243 
244  for (int i = 0; i < nparams; i++)
245  {
246  int nbytes;
247 
248  nbytes = pqTraceOutputInt32(f, message, cursor, false);
249  if (nbytes == -1)
250  continue;
251  pqTraceOutputNchar(f, nbytes, message, cursor);
252  }
253 
254  nparams = pqTraceOutputInt16(f, message, cursor);
255  for (int i = 0; i < nparams; i++)
256  pqTraceOutputInt16(f, message, cursor);
257 }
static void pqTraceOutputNchar(FILE *pfdebug, int len, const char *data, int *cursor)
Definition: fe-trace.c:188
static int pqTraceOutputInt16(FILE *pfdebug, const char *data, int *cursor)
Definition: fe-trace.c:125
int i
Definition: isn.c:73

References fprintf, i, pqTraceOutputInt16(), pqTraceOutputInt32(), pqTraceOutputNchar(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputByte1()

static void pqTraceOutputByte1 ( FILE *  pfdebug,
const char *  data,
int *  cursor 
)
static

Definition at line 106 of file fe-trace.c.

107 {
108  const char *v = data + *cursor;
109 
110  /*
111  * Show non-printable data in hex format, including the terminating \0
112  * that completes ErrorResponse and NoticeResponse messages.
113  */
114  if (!isprint((unsigned char) *v))
115  fprintf(pfdebug, " \\x%02x", *v);
116  else
117  fprintf(pfdebug, " %c", *v);
118  *cursor += 1;
119 }
const void * data

References data, and fprintf.

Referenced by pqTraceOutputC(), pqTraceOutputD(), pqTraceOutputG(), pqTraceOutputH(), pqTraceOutputNR(), pqTraceOutputW(), and pqTraceOutputZ().

◆ pqTraceOutputC()

static void pqTraceOutputC ( FILE *  f,
bool  toServer,
const char *  message,
int *  cursor 
)
static

Definition at line 261 of file fe-trace.c.

262 {
263  if (toServer)
264  {
265  fprintf(f, "Close\t");
266  pqTraceOutputByte1(f, message, cursor);
267  pqTraceOutputString(f, message, cursor, false);
268  }
269  else
270  {
271  fprintf(f, "CommandComplete\t");
272  pqTraceOutputString(f, message, cursor, false);
273  }
274 }
static void pqTraceOutputByte1(FILE *pfdebug, const char *data, int *cursor)
Definition: fe-trace.c:106

References fprintf, pqTraceOutputByte1(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputD()

static void pqTraceOutputD ( FILE *  f,
bool  toServer,
const char *  message,
int *  cursor 
)
static

Definition at line 278 of file fe-trace.c.

279 {
280  if (toServer)
281  {
282  fprintf(f, "Describe\t");
283  pqTraceOutputByte1(f, message, cursor);
284  pqTraceOutputString(f, message, cursor, false);
285  }
286  else
287  {
288  int nfields;
289  int len;
290  int i;
291 
292  fprintf(f, "DataRow\t");
293  nfields = pqTraceOutputInt16(f, message, cursor);
294  for (i = 0; i < nfields; i++)
295  {
296  len = pqTraceOutputInt32(f, message, cursor, false);
297  if (len == -1)
298  continue;
299  pqTraceOutputNchar(f, len, message, cursor);
300  }
301  }
302 }
const void size_t len

References fprintf, i, len, pqTraceOutputByte1(), pqTraceOutputInt16(), pqTraceOutputInt32(), pqTraceOutputNchar(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputE()

static void pqTraceOutputE ( FILE *  f,
bool  toServer,
const char *  message,
int *  cursor,
bool  regress 
)
static

Definition at line 327 of file fe-trace.c.

328 {
329  if (toServer)
330  {
331  fprintf(f, "Execute\t");
332  pqTraceOutputString(f, message, cursor, false);
333  pqTraceOutputInt32(f, message, cursor, false);
334  }
335  else
336  pqTraceOutputNR(f, "ErrorResponse", message, cursor, regress);
337 }
static void pqTraceOutputNR(FILE *f, const char *type, const char *message, int *cursor, bool regress)
Definition: fe-trace.c:306

References fprintf, pqTraceOutputInt32(), pqTraceOutputNR(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputf()

static void pqTraceOutputf ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 341 of file fe-trace.c.

342 {
343  fprintf(f, "CopyFail\t");
344  pqTraceOutputString(f, message, cursor, false);
345 }

References fprintf, and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputF()

static void pqTraceOutputF ( FILE *  f,
const char *  message,
int *  cursor,
bool  regress 
)
static

Definition at line 349 of file fe-trace.c.

350 {
351  int nfields;
352  int nbytes;
353 
354  fprintf(f, "FunctionCall\t");
355  pqTraceOutputInt32(f, message, cursor, regress);
356  nfields = pqTraceOutputInt16(f, message, cursor);
357 
358  for (int i = 0; i < nfields; i++)
359  pqTraceOutputInt16(f, message, cursor);
360 
361  nfields = pqTraceOutputInt16(f, message, cursor);
362 
363  for (int i = 0; i < nfields; i++)
364  {
365  nbytes = pqTraceOutputInt32(f, message, cursor, false);
366  if (nbytes == -1)
367  continue;
368  pqTraceOutputNchar(f, nbytes, message, cursor);
369  }
370 
371  pqTraceOutputInt16(f, message, cursor);
372 }

References fprintf, i, pqTraceOutputInt16(), pqTraceOutputInt32(), and pqTraceOutputNchar().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputG()

static void pqTraceOutputG ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 376 of file fe-trace.c.

377 {
378  int nfields;
379 
380  fprintf(f, "CopyInResponse\t");
381  pqTraceOutputByte1(f, message, cursor);
382  nfields = pqTraceOutputInt16(f, message, cursor);
383 
384  for (int i = 0; i < nfields; i++)
385  pqTraceOutputInt16(f, message, cursor);
386 }

References fprintf, i, pqTraceOutputByte1(), and pqTraceOutputInt16().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputH()

static void pqTraceOutputH ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 390 of file fe-trace.c.

391 {
392  int nfields;
393 
394  fprintf(f, "CopyOutResponse\t");
395  pqTraceOutputByte1(f, message, cursor);
396  nfields = pqTraceOutputInt16(f, message, cursor);
397 
398  for (int i = 0; i < nfields; i++)
399  pqTraceOutputInt16(f, message, cursor);
400 }

References fprintf, i, pqTraceOutputByte1(), and pqTraceOutputInt16().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputInt16()

static int pqTraceOutputInt16 ( FILE *  pfdebug,
const char *  data,
int *  cursor 
)
static

Definition at line 125 of file fe-trace.c.

126 {
127  uint16 tmp;
128  int result;
129 
130  memcpy(&tmp, data + *cursor, 2);
131  *cursor += 2;
132  result = (int) pg_ntoh16(tmp);
133  fprintf(pfdebug, " %d", result);
134 
135  return result;
136 }
unsigned short uint16
Definition: c.h:492
#define pg_ntoh16(x)
Definition: pg_bswap.h:124

References data, fprintf, and pg_ntoh16.

Referenced by pqTraceOutputB(), pqTraceOutputD(), pqTraceOutputF(), pqTraceOutputG(), pqTraceOutputH(), pqTraceOutputP(), pqTraceOutputt(), pqTraceOutputT(), and pqTraceOutputW().

◆ pqTraceOutputInt32()

static int pqTraceOutputInt32 ( FILE *  pfdebug,
const char *  data,
int *  cursor,
bool  suppress 
)
static

Definition at line 144 of file fe-trace.c.

145 {
146  int result;
147 
148  memcpy(&result, data + *cursor, 4);
149  *cursor += 4;
150  result = (int) pg_ntoh32(result);
151  if (suppress)
152  fprintf(pfdebug, " NNNN");
153  else
154  fprintf(pfdebug, " %d", result);
155 
156  return result;
157 }
#define pg_ntoh32(x)
Definition: pg_bswap.h:125

References data, fprintf, and pg_ntoh32.

Referenced by pqTraceOutputA(), pqTraceOutputB(), pqTraceOutputD(), pqTraceOutputE(), pqTraceOutputF(), pqTraceOutputK(), pqTraceOutputNoTypeByteMessage(), pqTraceOutputP(), pqTraceOutputR(), pqTraceOutputt(), pqTraceOutputT(), pqTraceOutputv(), and pqTraceOutputV().

◆ pqTraceOutputK()

static void pqTraceOutputK ( FILE *  f,
const char *  message,
int *  cursor,
bool  regress 
)
static

Definition at line 404 of file fe-trace.c.

405 {
406  fprintf(f, "BackendKeyData\t");
407  pqTraceOutputInt32(f, message, cursor, regress);
408  pqTraceOutputInt32(f, message, cursor, regress);
409 }

References fprintf, and pqTraceOutputInt32().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputMessage()

void pqTraceOutputMessage ( PGconn conn,
const char *  message,
bool  toServer 
)

Definition at line 529 of file fe-trace.c.

530 {
531  char id;
532  int length;
533  char *prefix = toServer ? "F" : "B";
534  int logCursor = 0;
535  bool regress;
536 
538  {
539  char timestr[128];
540 
541  pqTraceFormatTimestamp(timestr, sizeof(timestr));
542  fprintf(conn->Pfdebug, "%s\t", timestr);
543  }
544  regress = (conn->traceFlags & PQTRACE_REGRESS_MODE) != 0;
545 
546  id = message[logCursor++];
547 
548  memcpy(&length, message + logCursor, 4);
549  length = (int) pg_ntoh32(length);
550  logCursor += 4;
551 
552  /*
553  * In regress mode, suppress the length of ErrorResponse and
554  * NoticeResponse. The F (file name), L (line number) and R (routine
555  * name) fields can change as server code is modified, and if their
556  * lengths differ from the originals, that would break tests.
557  */
558  if (regress && !toServer && (id == 'E' || id == 'N'))
559  fprintf(conn->Pfdebug, "%s\tNN\t", prefix);
560  else
561  fprintf(conn->Pfdebug, "%s\t%d\t", prefix, length);
562 
563  switch (id)
564  {
565  case PqMsg_ParseComplete:
566  fprintf(conn->Pfdebug, "ParseComplete");
567  /* No message content */
568  break;
569  case PqMsg_BindComplete:
570  fprintf(conn->Pfdebug, "BindComplete");
571  /* No message content */
572  break;
573  case PqMsg_CloseComplete:
574  fprintf(conn->Pfdebug, "CloseComplete");
575  /* No message content */
576  break;
578  pqTraceOutputA(conn->Pfdebug, message, &logCursor, regress);
579  break;
580  case PqMsg_Bind:
581  pqTraceOutputB(conn->Pfdebug, message, &logCursor);
582  break;
583  case PqMsg_CopyDone:
584  fprintf(conn->Pfdebug, "CopyDone");
585  /* No message content */
586  break;
588  /* Close(F) and CommandComplete(B) use the same identifier. */
590  pqTraceOutputC(conn->Pfdebug, toServer, message, &logCursor);
591  break;
592  case PqMsg_CopyData:
593  /* Drop COPY data to reduce the overhead of logging. */
594  break;
595  case PqMsg_Describe:
596  /* Describe(F) and DataRow(B) use the same identifier. */
598  pqTraceOutputD(conn->Pfdebug, toServer, message, &logCursor);
599  break;
600  case PqMsg_Execute:
601  /* Execute(F) and ErrorResponse(B) use the same identifier. */
603  pqTraceOutputE(conn->Pfdebug, toServer, message, &logCursor,
604  regress);
605  break;
606  case PqMsg_CopyFail:
607  pqTraceOutputf(conn->Pfdebug, message, &logCursor);
608  break;
609  case PqMsg_FunctionCall:
610  pqTraceOutputF(conn->Pfdebug, message, &logCursor, regress);
611  break;
613  pqTraceOutputG(conn->Pfdebug, message, &logCursor);
614  break;
615  case PqMsg_Flush:
616  /* Flush(F) and CopyOutResponse(B) use the same identifier */
618  if (!toServer)
619  pqTraceOutputH(conn->Pfdebug, message, &logCursor);
620  else
621  fprintf(conn->Pfdebug, "Flush"); /* no message content */
622  break;
624  fprintf(conn->Pfdebug, "EmptyQueryResponse");
625  /* No message content */
626  break;
628  pqTraceOutputK(conn->Pfdebug, message, &logCursor, regress);
629  break;
630  case PqMsg_NoData:
631  fprintf(conn->Pfdebug, "NoData");
632  /* No message content */
633  break;
635  pqTraceOutputNR(conn->Pfdebug, "NoticeResponse", message,
636  &logCursor, regress);
637  break;
638  case PqMsg_Parse:
639  pqTraceOutputP(conn->Pfdebug, message, &logCursor, regress);
640  break;
641  case PqMsg_Query:
642  pqTraceOutputQ(conn->Pfdebug, message, &logCursor);
643  break;
645  pqTraceOutputR(conn->Pfdebug, message, &logCursor);
646  break;
648  fprintf(conn->Pfdebug, "PortalSuspended");
649  /* No message content */
650  break;
651  case PqMsg_Sync:
652  /* Parameter Status(B) and Sync(F) use the same identifier */
654  if (!toServer)
655  pqTraceOutputS(conn->Pfdebug, message, &logCursor);
656  else
657  fprintf(conn->Pfdebug, "Sync"); /* no message content */
658  break;
660  pqTraceOutputt(conn->Pfdebug, message, &logCursor, regress);
661  break;
663  pqTraceOutputT(conn->Pfdebug, message, &logCursor, regress);
664  break;
666  pqTraceOutputv(conn->Pfdebug, message, &logCursor);
667  break;
669  pqTraceOutputV(conn->Pfdebug, message, &logCursor);
670  break;
672  pqTraceOutputW(conn->Pfdebug, message, &logCursor, length);
673  break;
674  case PqMsg_Terminate:
675  fprintf(conn->Pfdebug, "Terminate");
676  /* No message content */
677  break;
678  case PqMsg_ReadyForQuery:
679  pqTraceOutputZ(conn->Pfdebug, message, &logCursor);
680  break;
681  default:
682  fprintf(conn->Pfdebug, "Unknown message: %02x", id);
683  break;
684  }
685 
686  fputc('\n', conn->Pfdebug);
687 
688  /*
689  * Verify the printing routine did it right. Note that the one-byte
690  * message identifier is not included in the length, but our cursor does
691  * include it.
692  */
693  if (logCursor - 1 != length)
695  "mismatched message length: consumed %d, expected %d\n",
696  logCursor - 1, length);
697 }
static void pqTraceOutputQ(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:428
static void pqTraceOutputS(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:444
static void pqTraceOutputH(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:390
static void pqTraceOutputZ(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:519
static void pqTraceOutputW(FILE *f, const char *message, int *cursor, int length)
Definition: fe-trace.c:508
static void pqTraceOutputE(FILE *f, bool toServer, const char *message, int *cursor, bool regress)
Definition: fe-trace.c:327
static void pqTraceOutputV(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:496
static void pqTraceOutputK(FILE *f, const char *message, int *cursor, bool regress)
Definition: fe-trace.c:404
static void pqTraceOutputF(FILE *f, const char *message, int *cursor, bool regress)
Definition: fe-trace.c:349
static void pqTraceOutputP(FILE *f, const char *message, int *cursor, bool regress)
Definition: fe-trace.c:413
static void pqTraceOutputT(FILE *f, const char *message, int *cursor, bool regress)
Definition: fe-trace.c:466
static void pqTraceOutputA(FILE *f, const char *message, int *cursor, bool regress)
Definition: fe-trace.c:220
static void pqTraceOutputD(FILE *f, bool toServer, const char *message, int *cursor)
Definition: fe-trace.c:278
static void pqTraceOutputG(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:376
static void pqTraceOutputf(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:341
static void pqTraceOutputR(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:436
static void pqTraceOutputt(FILE *f, const char *message, int *cursor, bool regress)
Definition: fe-trace.c:453
static void pqTraceOutputB(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:230
static void pqTraceOutputv(FILE *f, const char *message, int *cursor)
Definition: fe-trace.c:487
static void pqTraceOutputC(FILE *f, bool toServer, const char *message, int *cursor)
Definition: fe-trace.c:261
static void pqTraceFormatTimestamp(char *timestr, size_t ts_len)
Definition: fe-trace.c:80
#define PQTRACE_SUPPRESS_TIMESTAMPS
Definition: libpq-fe.h:441
#define PQTRACE_REGRESS_MODE
Definition: libpq-fe.h:443
Assert(fmt[strlen(fmt) - 1] !='\n')
#define PqMsg_CloseComplete
Definition: protocol.h:40
#define PqMsg_CopyDone
Definition: protocol.h:64
#define PqMsg_NotificationResponse
Definition: protocol.h:41
#define PqMsg_BindComplete
Definition: protocol.h:39
#define PqMsg_CopyData
Definition: protocol.h:65
#define PqMsg_ParameterDescription
Definition: protocol.h:58
#define PqMsg_FunctionCall
Definition: protocol.h:23
#define PqMsg_Describe
Definition: protocol.h:21
#define PqMsg_FunctionCallResponse
Definition: protocol.h:53
#define PqMsg_ReadyForQuery
Definition: protocol.h:55
#define PqMsg_AuthenticationRequest
Definition: protocol.h:50
#define PqMsg_CopyInResponse
Definition: protocol.h:45
#define PqMsg_EmptyQueryResponse
Definition: protocol.h:47
#define PqMsg_RowDescription
Definition: protocol.h:52
#define PqMsg_CopyBothResponse
Definition: protocol.h:54
#define PqMsg_ParameterStatus
Definition: protocol.h:51
#define PqMsg_NoData
Definition: protocol.h:56
#define PqMsg_NegotiateProtocolVersion
Definition: protocol.h:59
#define PqMsg_PortalSuspended
Definition: protocol.h:57
#define PqMsg_Parse
Definition: protocol.h:25
#define PqMsg_Bind
Definition: protocol.h:19
#define PqMsg_Sync
Definition: protocol.h:27
#define PqMsg_CopyFail
Definition: protocol.h:29
#define PqMsg_Flush
Definition: protocol.h:24
#define PqMsg_BackendKeyData
Definition: protocol.h:48
#define PqMsg_CommandComplete
Definition: protocol.h:42
#define PqMsg_Query
Definition: protocol.h:26
#define PqMsg_ErrorResponse
Definition: protocol.h:44
#define PqMsg_DataRow
Definition: protocol.h:43
#define PqMsg_NoticeResponse
Definition: protocol.h:49
#define PqMsg_Terminate
Definition: protocol.h:28
#define PqMsg_Execute
Definition: protocol.h:22
#define PqMsg_Close
Definition: protocol.h:20
#define PqMsg_CopyOutResponse
Definition: protocol.h:46
#define PqMsg_ParseComplete
Definition: protocol.h:38

References Assert(), conn, fprintf, pg_conn::Pfdebug, pg_ntoh32, PqMsg_AuthenticationRequest, PqMsg_BackendKeyData, PqMsg_Bind, PqMsg_BindComplete, PqMsg_Close, PqMsg_CloseComplete, PqMsg_CommandComplete, PqMsg_CopyBothResponse, PqMsg_CopyData, PqMsg_CopyDone, PqMsg_CopyFail, PqMsg_CopyInResponse, PqMsg_CopyOutResponse, PqMsg_DataRow, PqMsg_Describe, PqMsg_EmptyQueryResponse, PqMsg_ErrorResponse, PqMsg_Execute, PqMsg_Flush, PqMsg_FunctionCall, PqMsg_FunctionCallResponse, PqMsg_NegotiateProtocolVersion, PqMsg_NoData, PqMsg_NoticeResponse, PqMsg_NotificationResponse, PqMsg_ParameterDescription, PqMsg_ParameterStatus, PqMsg_Parse, PqMsg_ParseComplete, PqMsg_PortalSuspended, PqMsg_Query, PqMsg_ReadyForQuery, PqMsg_RowDescription, PqMsg_Sync, PqMsg_Terminate, PQTRACE_REGRESS_MODE, PQTRACE_SUPPRESS_TIMESTAMPS, pqTraceFormatTimestamp(), pqTraceOutputA(), pqTraceOutputB(), pqTraceOutputC(), pqTraceOutputD(), pqTraceOutputE(), pqTraceOutputf(), pqTraceOutputF(), pqTraceOutputG(), pqTraceOutputH(), pqTraceOutputK(), pqTraceOutputNR(), pqTraceOutputP(), pqTraceOutputQ(), pqTraceOutputR(), pqTraceOutputS(), pqTraceOutputt(), pqTraceOutputT(), pqTraceOutputv(), pqTraceOutputV(), pqTraceOutputW(), pqTraceOutputZ(), and pg_conn::traceFlags.

Referenced by getCopyDataMessage(), pqFunctionCall3(), pqParseInput3(), and pqPutMsgEnd().

◆ pqTraceOutputNchar()

static void pqTraceOutputNchar ( FILE *  pfdebug,
int  len,
const char *  data,
int *  cursor 
)
static

Definition at line 188 of file fe-trace.c.

189 {
190  int i,
191  next; /* first char not yet printed */
192  const char *v = data + *cursor;
193 
194  fprintf(pfdebug, " \'");
195 
196  for (next = i = 0; i < len; ++i)
197  {
198  if (isprint((unsigned char) v[i]))
199  continue;
200  else
201  {
202  fwrite(v + next, 1, i - next, pfdebug);
203  fprintf(pfdebug, "\\x%02x", v[i]);
204  next = i + 1;
205  }
206  }
207  if (next < len)
208  fwrite(v + next, 1, len - next, pfdebug);
209 
210  fprintf(pfdebug, "\'");
211  *cursor += len;
212 }
static int32 next
Definition: blutils.c:221

References data, fprintf, i, len, and next.

Referenced by pqTraceOutputB(), pqTraceOutputD(), pqTraceOutputF(), and pqTraceOutputV().

◆ pqTraceOutputNoTypeByteMessage()

void pqTraceOutputNoTypeByteMessage ( PGconn conn,
const char *  message 
)

Definition at line 704 of file fe-trace.c.

705 {
706  int length;
707  int logCursor = 0;
708 
710  {
711  char timestr[128];
712 
713  pqTraceFormatTimestamp(timestr, sizeof(timestr));
714  fprintf(conn->Pfdebug, "%s\t", timestr);
715  }
716 
717  memcpy(&length, message + logCursor, 4);
718  length = (int) pg_ntoh32(length);
719  logCursor += 4;
720 
721  fprintf(conn->Pfdebug, "F\t%d\t", length);
722 
723  switch (length)
724  {
725  case 16: /* CancelRequest */
726  fprintf(conn->Pfdebug, "CancelRequest\t");
727  pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, false);
728  pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, false);
729  pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, false);
730  break;
731  case 8: /* GSSENCRequest or SSLRequest */
732  /* These messages do not reach here. */
733  default:
734  fprintf(conn->Pfdebug, "Unknown message: length is %d", length);
735  break;
736  }
737 
738  fputc('\n', conn->Pfdebug);
739 }

References conn, fprintf, pg_conn::Pfdebug, pg_ntoh32, PQTRACE_SUPPRESS_TIMESTAMPS, pqTraceFormatTimestamp(), pqTraceOutputInt32(), and pg_conn::traceFlags.

Referenced by pqPutMsgEnd().

◆ pqTraceOutputNR()

static void pqTraceOutputNR ( FILE *  f,
const char *  type,
const char *  message,
int *  cursor,
bool  regress 
)
static

Definition at line 306 of file fe-trace.c.

308 {
309  fprintf(f, "%s\t", type);
310  for (;;)
311  {
312  char field;
313  bool suppress;
314 
315  pqTraceOutputByte1(f, message, cursor);
316  field = message[*cursor - 1];
317  if (field == '\0')
318  break;
319 
320  suppress = regress && (field == 'L' || field == 'F' || field == 'R');
321  pqTraceOutputString(f, message, cursor, suppress);
322  }
323 }
const char * type

References fprintf, pqTraceOutputByte1(), pqTraceOutputString(), and type.

Referenced by pqTraceOutputE(), and pqTraceOutputMessage().

◆ pqTraceOutputP()

static void pqTraceOutputP ( FILE *  f,
const char *  message,
int *  cursor,
bool  regress 
)
static

Definition at line 413 of file fe-trace.c.

414 {
415  int nparams;
416 
417  fprintf(f, "Parse\t");
418  pqTraceOutputString(f, message, cursor, false);
419  pqTraceOutputString(f, message, cursor, false);
420  nparams = pqTraceOutputInt16(f, message, cursor);
421 
422  for (int i = 0; i < nparams; i++)
423  pqTraceOutputInt32(f, message, cursor, regress);
424 }

References fprintf, i, pqTraceOutputInt16(), pqTraceOutputInt32(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputQ()

static void pqTraceOutputQ ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 428 of file fe-trace.c.

429 {
430  fprintf(f, "Query\t");
431  pqTraceOutputString(f, message, cursor, false);
432 }

References fprintf, and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputR()

static void pqTraceOutputR ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 436 of file fe-trace.c.

437 {
438  fprintf(f, "Authentication\t");
439  pqTraceOutputInt32(f, message, cursor, false);
440 }

References fprintf, and pqTraceOutputInt32().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputS()

static void pqTraceOutputS ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 444 of file fe-trace.c.

445 {
446  fprintf(f, "ParameterStatus\t");
447  pqTraceOutputString(f, message, cursor, false);
448  pqTraceOutputString(f, message, cursor, false);
449 }

References fprintf, and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputString()

static void pqTraceOutputString ( FILE *  pfdebug,
const char *  data,
int *  cursor,
bool  suppress 
)
static

Definition at line 163 of file fe-trace.c.

164 {
165  int len;
166 
167  if (suppress)
168  {
169  fprintf(pfdebug, " \"SSSS\"");
170  *cursor += strlen(data + *cursor) + 1;
171  }
172  else
173  {
174  len = fprintf(pfdebug, " \"%s\"", data + *cursor);
175 
176  /*
177  * This is a null-terminated string. So add 1 after subtracting 3
178  * which is the double quotes and space length from len.
179  */
180  *cursor += (len - 3 + 1);
181  }
182 }

References data, fprintf, and len.

Referenced by pqTraceOutputA(), pqTraceOutputB(), pqTraceOutputC(), pqTraceOutputD(), pqTraceOutputE(), pqTraceOutputf(), pqTraceOutputNR(), pqTraceOutputP(), pqTraceOutputQ(), pqTraceOutputS(), and pqTraceOutputT().

◆ pqTraceOutputt()

static void pqTraceOutputt ( FILE *  f,
const char *  message,
int *  cursor,
bool  regress 
)
static

Definition at line 453 of file fe-trace.c.

454 {
455  int nfields;
456 
457  fprintf(f, "ParameterDescription\t");
458  nfields = pqTraceOutputInt16(f, message, cursor);
459 
460  for (int i = 0; i < nfields; i++)
461  pqTraceOutputInt32(f, message, cursor, regress);
462 }

References fprintf, i, pqTraceOutputInt16(), and pqTraceOutputInt32().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputT()

static void pqTraceOutputT ( FILE *  f,
const char *  message,
int *  cursor,
bool  regress 
)
static

Definition at line 466 of file fe-trace.c.

467 {
468  int nfields;
469 
470  fprintf(f, "RowDescription\t");
471  nfields = pqTraceOutputInt16(f, message, cursor);
472 
473  for (int i = 0; i < nfields; i++)
474  {
475  pqTraceOutputString(f, message, cursor, false);
476  pqTraceOutputInt32(f, message, cursor, regress);
477  pqTraceOutputInt16(f, message, cursor);
478  pqTraceOutputInt32(f, message, cursor, regress);
479  pqTraceOutputInt16(f, message, cursor);
480  pqTraceOutputInt32(f, message, cursor, false);
481  pqTraceOutputInt16(f, message, cursor);
482  }
483 }

References fprintf, i, pqTraceOutputInt16(), pqTraceOutputInt32(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputv()

static void pqTraceOutputv ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 487 of file fe-trace.c.

488 {
489  fprintf(f, "NegotiateProtocolVersion\t");
490  pqTraceOutputInt32(f, message, cursor, false);
491  pqTraceOutputInt32(f, message, cursor, false);
492 }

References fprintf, and pqTraceOutputInt32().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputV()

static void pqTraceOutputV ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 496 of file fe-trace.c.

497 {
498  int len;
499 
500  fprintf(f, "FunctionCallResponse\t");
501  len = pqTraceOutputInt32(f, message, cursor, false);
502  if (len != -1)
503  pqTraceOutputNchar(f, len, message, cursor);
504 }

References fprintf, len, pqTraceOutputInt32(), and pqTraceOutputNchar().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputW()

static void pqTraceOutputW ( FILE *  f,
const char *  message,
int *  cursor,
int  length 
)
static

Definition at line 508 of file fe-trace.c.

509 {
510  fprintf(f, "CopyBothResponse\t");
511  pqTraceOutputByte1(f, message, cursor);
512 
513  while (length > *cursor)
514  pqTraceOutputInt16(f, message, cursor);
515 }

References fprintf, pqTraceOutputByte1(), and pqTraceOutputInt16().

Referenced by pqTraceOutputMessage().

◆ pqTraceOutputZ()

static void pqTraceOutputZ ( FILE *  f,
const char *  message,
int *  cursor 
)
static

Definition at line 519 of file fe-trace.c.

520 {
521  fprintf(f, "ReadyForQuery\t");
522  pqTraceOutputByte1(f, message, cursor);
523 }

References fprintf, and pqTraceOutputByte1().

Referenced by pqTraceOutputMessage().

◆ PQuntrace()

void PQuntrace ( PGconn conn)

Definition at line 49 of file fe-trace.c.

50 {
51  if (conn == NULL)
52  return;
53  if (conn->Pfdebug)
54  {
56  conn->Pfdebug = NULL;
57  }
58 
59  conn->traceFlags = 0;
60 }
static void const char fflush(stdout)

References conn, fflush(), pg_conn::Pfdebug, and pg_conn::traceFlags.

Referenced by PQtrace().