1 /*-------------------------------------------------------------------------
2 *
3 * FILE
4 * fe-misc.c
5 *
6 * DESCRIPTION
7 * miscellaneous useful functions
8 *
9 * The communication routines here are analogous to the ones in
10 * backend/libpq/pqcomm.c and backend/libpq/pqformat.c, but operate
11 * in the considerably different environment of the frontend libpq.
12 * In particular, we work with a bare nonblock-mode socket, rather than
13 * a stdio stream, so that we can avoid unwanted blocking of the application.
14 *
15 * XXX: MOVE DEBUG PRINTOUT TO HIGHER LEVEL. As is, block and restart
16 * will cause repeat printouts.
17 *
18 * We must speak the same transmitted data representations as the backend
19 * routines.
20 *
21 *
22 * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
23 * Portions Copyright (c) 1994, Regents of the University of California
24 *
25 * IDENTIFICATION
26 * src/interfaces/libpq/fe-misc.c
27 *
28 *-------------------------------------------------------------------------
29 */
30
31 #include "postgres_fe.h"
32
33 #include <signal.h>
34 #include <time.h>
35
36 #ifdef WIN32
37 #include "win32.h"
38 #else
39 #include <unistd.h>
40 #include <sys/time.h>
41 #endif
42
43 #ifdef HAVE_POLL_H
44 #include <poll.h>
45 #endif
46 #ifdef HAVE_SYS_SELECT_H
47 #include <sys/select.h>
48 #endif
49
50 #include "libpq-fe.h"
51 #include "libpq-int.h"
52 #include "mb/pg_wchar.h"
53 #include "pg_config_paths.h"
54 #include "port/pg_bswap.h"
55
56 static int pqPutMsgBytes(const void *buf, size_t len, PGconn *conn);
57 static int pqSendSome(PGconn *conn, int len);
58 static int pqSocketCheck(PGconn *conn, int forRead, int forWrite,
59 time_t end_time);
60 static int pqSocketPoll(int sock, int forRead, int forWrite, time_t end_time);
61
62 /*
63 * PQlibVersion: return the libpq version number
64 */
65 int
PQlibVersion(void)66 PQlibVersion(void)
67 {
68 return PG_VERSION_NUM;
69 }
70
71 /*
72 * fputnbytes: print exactly N bytes to a file
73 *
74 * We avoid using %.*s here because it can misbehave if the data
75 * is not valid in what libc thinks is the prevailing encoding.
76 */
77 static void
fputnbytes(FILE * f,const char * str,size_t n)78 fputnbytes(FILE *f, const char *str, size_t n)
79 {
80 while (n-- > 0)
81 fputc(*str++, f);
82 }
83
84
85 /*
86 * pqGetc: get 1 character from the connection
87 *
88 * All these routines return 0 on success, EOF on error.
89 * Note that for the Get routines, EOF only means there is not enough
90 * data in the buffer, not that there is necessarily a hard error.
91 */
92 int
pqGetc(char * result,PGconn * conn)93 pqGetc(char *result, PGconn *conn)
94 {
95 if (conn->inCursor >= conn->inEnd)
96 return EOF;
97
98 *result = conn->inBuffer[conn->inCursor++];
99
100 if (conn->Pfdebug)
101 fprintf(conn->Pfdebug, "From backend> %c\n", *result);
102
103 return 0;
104 }
105
106
107 /*
108 * pqPutc: write 1 char to the current message
109 */
110 int
pqPutc(char c,PGconn * conn)111 pqPutc(char c, PGconn *conn)
112 {
113 if (pqPutMsgBytes(&c, 1, conn))
114 return EOF;
115
116 if (conn->Pfdebug)
117 fprintf(conn->Pfdebug, "To backend> %c\n", c);
118
119 return 0;
120 }
121
122
123 /*
124 * pqGets[_append]:
125 * get a null-terminated string from the connection,
126 * and store it in an expansible PQExpBuffer.
127 * If we run out of memory, all of the string is still read,
128 * but the excess characters are silently discarded.
129 */
130 static int
pqGets_internal(PQExpBuffer buf,PGconn * conn,bool resetbuffer)131 pqGets_internal(PQExpBuffer buf, PGconn *conn, bool resetbuffer)
132 {
133 /* Copy conn data to locals for faster search loop */
134 char *inBuffer = conn->inBuffer;
135 int inCursor = conn->inCursor;
136 int inEnd = conn->inEnd;
137 int slen;
138
139 while (inCursor < inEnd && inBuffer[inCursor])
140 inCursor++;
141
142 if (inCursor >= inEnd)
143 return EOF;
144
145 slen = inCursor - conn->inCursor;
146
147 if (resetbuffer)
148 resetPQExpBuffer(buf);
149
150 appendBinaryPQExpBuffer(buf, inBuffer + conn->inCursor, slen);
151
152 conn->inCursor = ++inCursor;
153
154 if (conn->Pfdebug)
155 fprintf(conn->Pfdebug, "From backend> \"%s\"\n",
156 buf->data);
157
158 return 0;
159 }
160
161 int
pqGets(PQExpBuffer buf,PGconn * conn)162 pqGets(PQExpBuffer buf, PGconn *conn)
163 {
164 return pqGets_internal(buf, conn, true);
165 }
166
167 int
pqGets_append(PQExpBuffer buf,PGconn * conn)168 pqGets_append(PQExpBuffer buf, PGconn *conn)
169 {
170 return pqGets_internal(buf, conn, false);
171 }
172
173
174 /*
175 * pqPuts: write a null-terminated string to the current message
176 */
177 int
pqPuts(const char * s,PGconn * conn)178 pqPuts(const char *s, PGconn *conn)
179 {
180 if (pqPutMsgBytes(s, strlen(s) + 1, conn))
181 return EOF;
182
183 if (conn->Pfdebug)
184 fprintf(conn->Pfdebug, "To backend> \"%s\"\n", s);
185
186 return 0;
187 }
188
189 /*
190 * pqGetnchar:
191 * get a string of exactly len bytes in buffer s, no null termination
192 */
193 int
pqGetnchar(char * s,size_t len,PGconn * conn)194 pqGetnchar(char *s, size_t len, PGconn *conn)
195 {
196 if (len > (size_t) (conn->inEnd - conn->inCursor))
197 return EOF;
198
199 memcpy(s, conn->inBuffer + conn->inCursor, len);
200 /* no terminating null */
201
202 conn->inCursor += len;
203
204 if (conn->Pfdebug)
205 {
206 fprintf(conn->Pfdebug, "From backend (%lu)> ", (unsigned long) len);
207 fputnbytes(conn->Pfdebug, s, len);
208 fprintf(conn->Pfdebug, "\n");
209 }
210
211 return 0;
212 }
213
214 /*
215 * pqSkipnchar:
216 * skip over len bytes in input buffer.
217 *
218 * Note: this is primarily useful for its debug output, which should
219 * be exactly the same as for pqGetnchar. We assume the data in question
220 * will actually be used, but just isn't getting copied anywhere as yet.
221 */
222 int
pqSkipnchar(size_t len,PGconn * conn)223 pqSkipnchar(size_t len, PGconn *conn)
224 {
225 if (len > (size_t) (conn->inEnd - conn->inCursor))
226 return EOF;
227
228 if (conn->Pfdebug)
229 {
230 fprintf(conn->Pfdebug, "From backend (%lu)> ", (unsigned long) len);
231 fputnbytes(conn->Pfdebug, conn->inBuffer + conn->inCursor, len);
232 fprintf(conn->Pfdebug, "\n");
233 }
234
235 conn->inCursor += len;
236
237 return 0;
238 }
239
240 /*
241 * pqPutnchar:
242 * write exactly len bytes to the current message
243 */
244 int
pqPutnchar(const char * s,size_t len,PGconn * conn)245 pqPutnchar(const char *s, size_t len, PGconn *conn)
246 {
247 if (pqPutMsgBytes(s, len, conn))
248 return EOF;
249
250 if (conn->Pfdebug)
251 {
252 fprintf(conn->Pfdebug, "To backend> ");
253 fputnbytes(conn->Pfdebug, s, len);
254 fprintf(conn->Pfdebug, "\n");
255 }
256
257 return 0;
258 }
259
260 /*
261 * pqGetInt
262 * read a 2 or 4 byte integer and convert from network byte order
263 * to local byte order
264 */
265 int
pqGetInt(int * result,size_t bytes,PGconn * conn)266 pqGetInt(int *result, size_t bytes, PGconn *conn)
267 {
268 uint16 tmp2;
269 uint32 tmp4;
270
271 switch (bytes)
272 {
273 case 2:
274 if (conn->inCursor + 2 > conn->inEnd)
275 return EOF;
276 memcpy(&tmp2, conn->inBuffer + conn->inCursor, 2);
277 conn->inCursor += 2;
278 *result = (int) pg_ntoh16(tmp2);
279 break;
280 case 4:
281 if (conn->inCursor + 4 > conn->inEnd)
282 return EOF;
283 memcpy(&tmp4, conn->inBuffer + conn->inCursor, 4);
284 conn->inCursor += 4;
285 *result = (int) pg_ntoh32(tmp4);
286 break;
287 default:
288 pqInternalNotice(&conn->noticeHooks,
289 "integer of size %lu not supported by pqGetInt",
290 (unsigned long) bytes);
291 return EOF;
292 }
293
294 if (conn->Pfdebug)
295 fprintf(conn->Pfdebug, "From backend (#%lu)> %d\n", (unsigned long) bytes, *result);
296
297 return 0;
298 }
299
300 /*
301 * pqPutInt
302 * write an integer of 2 or 4 bytes, converting from host byte order
303 * to network byte order.
304 */
305 int
pqPutInt(int value,size_t bytes,PGconn * conn)306 pqPutInt(int value, size_t bytes, PGconn *conn)
307 {
308 uint16 tmp2;
309 uint32 tmp4;
310
311 switch (bytes)
312 {
313 case 2:
314 tmp2 = pg_hton16((uint16) value);
315 if (pqPutMsgBytes((const char *) &tmp2, 2, conn))
316 return EOF;
317 break;
318 case 4:
319 tmp4 = pg_hton32((uint32) value);
320 if (pqPutMsgBytes((const char *) &tmp4, 4, conn))
321 return EOF;
322 break;
323 default:
324 pqInternalNotice(&conn->noticeHooks,
325 "integer of size %lu not supported by pqPutInt",
326 (unsigned long) bytes);
327 return EOF;
328 }
329
330 if (conn->Pfdebug)
331 fprintf(conn->Pfdebug, "To backend (%lu#)> %d\n", (unsigned long) bytes, value);
332
333 return 0;
334 }
335
336 /*
337 * Make sure conn's output buffer can hold bytes_needed bytes (caller must
338 * include already-stored data into the value!)
339 *
340 * Returns 0 on success, EOF if failed to enlarge buffer
341 */
342 int
pqCheckOutBufferSpace(size_t bytes_needed,PGconn * conn)343 pqCheckOutBufferSpace(size_t bytes_needed, PGconn *conn)
344 {
345 int newsize = conn->outBufSize;
346 char *newbuf;
347
348 /* Quick exit if we have enough space */
349 if (bytes_needed <= (size_t) newsize)
350 return 0;
351
352 /*
353 * If we need to enlarge the buffer, we first try to double it in size; if
354 * that doesn't work, enlarge in multiples of 8K. This avoids thrashing
355 * the malloc pool by repeated small enlargements.
356 *
357 * Note: tests for newsize > 0 are to catch integer overflow.
358 */
359 do
360 {
361 newsize *= 2;
362 } while (newsize > 0 && bytes_needed > (size_t) newsize);
363
364 if (newsize > 0 && bytes_needed <= (size_t) newsize)
365 {
366 newbuf = realloc(conn->outBuffer, newsize);
367 if (newbuf)
368 {
369 /* realloc succeeded */
370 conn->outBuffer = newbuf;
371 conn->outBufSize = newsize;
372 return 0;
373 }
374 }
375
376 newsize = conn->outBufSize;
377 do
378 {
379 newsize += 8192;
380 } while (newsize > 0 && bytes_needed > (size_t) newsize);
381
382 if (newsize > 0 && bytes_needed <= (size_t) newsize)
383 {
384 newbuf = realloc(conn->outBuffer, newsize);
385 if (newbuf)
386 {
387 /* realloc succeeded */
388 conn->outBuffer = newbuf;
389 conn->outBufSize = newsize;
390 return 0;
391 }
392 }
393
394 /* realloc failed. Probably out of memory */
395 printfPQExpBuffer(&conn->errorMessage,
396 "cannot allocate memory for output buffer\n");
397 return EOF;
398 }
399
400 /*
401 * Make sure conn's input buffer can hold bytes_needed bytes (caller must
402 * include already-stored data into the value!)
403 *
404 * Returns 0 on success, EOF if failed to enlarge buffer
405 */
406 int
pqCheckInBufferSpace(size_t bytes_needed,PGconn * conn)407 pqCheckInBufferSpace(size_t bytes_needed, PGconn *conn)
408 {
409 int newsize = conn->inBufSize;
410 char *newbuf;
411
412 /* Quick exit if we have enough space */
413 if (bytes_needed <= (size_t) newsize)
414 return 0;
415
416 /*
417 * Before concluding that we need to enlarge the buffer, left-justify
418 * whatever is in it and recheck. The caller's value of bytes_needed
419 * includes any data to the left of inStart, but we can delete that in
420 * preference to enlarging the buffer. It's slightly ugly to have this
421 * function do this, but it's better than making callers worry about it.
422 */
423 bytes_needed -= conn->inStart;
424
425 if (conn->inStart < conn->inEnd)
426 {
427 if (conn->inStart > 0)
428 {
429 memmove(conn->inBuffer, conn->inBuffer + conn->inStart,
430 conn->inEnd - conn->inStart);
431 conn->inEnd -= conn->inStart;
432 conn->inCursor -= conn->inStart;
433 conn->inStart = 0;
434 }
435 }
436 else
437 {
438 /* buffer is logically empty, reset it */
439 conn->inStart = conn->inCursor = conn->inEnd = 0;
440 }
441
442 /* Recheck whether we have enough space */
443 if (bytes_needed <= (size_t) newsize)
444 return 0;
445
446 /*
447 * If we need to enlarge the buffer, we first try to double it in size; if
448 * that doesn't work, enlarge in multiples of 8K. This avoids thrashing
449 * the malloc pool by repeated small enlargements.
450 *
451 * Note: tests for newsize > 0 are to catch integer overflow.
452 */
453 do
454 {
455 newsize *= 2;
456 } while (newsize > 0 && bytes_needed > (size_t) newsize);
457
458 if (newsize > 0 && bytes_needed <= (size_t) newsize)
459 {
460 newbuf = realloc(conn->inBuffer, newsize);
461 if (newbuf)
462 {
463 /* realloc succeeded */
464 conn->inBuffer = newbuf;
465 conn->inBufSize = newsize;
466 return 0;
467 }
468 }
469
470 newsize = conn->inBufSize;
471 do
472 {
473 newsize += 8192;
474 } while (newsize > 0 && bytes_needed > (size_t) newsize);
475
476 if (newsize > 0 && bytes_needed <= (size_t) newsize)
477 {
478 newbuf = realloc(conn->inBuffer, newsize);
479 if (newbuf)
480 {
481 /* realloc succeeded */
482 conn->inBuffer = newbuf;
483 conn->inBufSize = newsize;
484 return 0;
485 }
486 }
487
488 /* realloc failed. Probably out of memory */
489 printfPQExpBuffer(&conn->errorMessage,
490 "cannot allocate memory for input buffer\n");
491 return EOF;
492 }
493
494 /*
495 * pqPutMsgStart: begin construction of a message to the server
496 *
497 * msg_type is the message type byte, or 0 for a message without type byte
498 * (only startup messages have no type byte)
499 *
500 * force_len forces the message to have a length word; otherwise, we add
501 * a length word if protocol 3.
502 *
503 * Returns 0 on success, EOF on error
504 *
505 * The idea here is that we construct the message in conn->outBuffer,
506 * beginning just past any data already in outBuffer (ie, at
507 * outBuffer+outCount). We enlarge the buffer as needed to hold the message.
508 * When the message is complete, we fill in the length word (if needed) and
509 * then advance outCount past the message, making it eligible to send.
510 *
511 * The state variable conn->outMsgStart points to the incomplete message's
512 * length word: it is either outCount or outCount+1 depending on whether
513 * there is a type byte. If we are sending a message without length word
514 * (pre protocol 3.0 only), then outMsgStart is -1. The state variable
515 * conn->outMsgEnd is the end of the data collected so far.
516 */
517 int
pqPutMsgStart(char msg_type,bool force_len,PGconn * conn)518 pqPutMsgStart(char msg_type, bool force_len, PGconn *conn)
519 {
520 int lenPos;
521 int endPos;
522
523 /* allow room for message type byte */
524 if (msg_type)
525 endPos = conn->outCount + 1;
526 else
527 endPos = conn->outCount;
528
529 /* do we want a length word? */
530 if (force_len || PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
531 {
532 lenPos = endPos;
533 /* allow room for message length */
534 endPos += 4;
535 }
536 else
537 lenPos = -1;
538
539 /* make sure there is room for message header */
540 if (pqCheckOutBufferSpace(endPos, conn))
541 return EOF;
542 /* okay, save the message type byte if any */
543 if (msg_type)
544 conn->outBuffer[conn->outCount] = msg_type;
545 /* set up the message pointers */
546 conn->outMsgStart = lenPos;
547 conn->outMsgEnd = endPos;
548 /* length word, if needed, will be filled in by pqPutMsgEnd */
549
550 if (conn->Pfdebug)
551 fprintf(conn->Pfdebug, "To backend> Msg %c\n",
552 msg_type ? msg_type : ' ');
553
554 return 0;
555 }
556
557 /*
558 * pqPutMsgBytes: add bytes to a partially-constructed message
559 *
560 * Returns 0 on success, EOF on error
561 */
562 static int
pqPutMsgBytes(const void * buf,size_t len,PGconn * conn)563 pqPutMsgBytes(const void *buf, size_t len, PGconn *conn)
564 {
565 /* make sure there is room for it */
566 if (pqCheckOutBufferSpace(conn->outMsgEnd + len, conn))
567 return EOF;
568 /* okay, save the data */
569 memcpy(conn->outBuffer + conn->outMsgEnd, buf, len);
570 conn->outMsgEnd += len;
571 /* no Pfdebug call here, caller should do it */
572 return 0;
573 }
574
575 /*
576 * pqPutMsgEnd: finish constructing a message and possibly send it
577 *
578 * Returns 0 on success, EOF on error
579 *
580 * We don't actually send anything here unless we've accumulated at least
581 * 8K worth of data (the typical size of a pipe buffer on Unix systems).
582 * This avoids sending small partial packets. The caller must use pqFlush
583 * when it's important to flush all the data out to the server.
584 */
585 int
pqPutMsgEnd(PGconn * conn)586 pqPutMsgEnd(PGconn *conn)
587 {
588 if (conn->Pfdebug)
589 fprintf(conn->Pfdebug, "To backend> Msg complete, length %u\n",
590 conn->outMsgEnd - conn->outCount);
591
592 /* Fill in length word if needed */
593 if (conn->outMsgStart >= 0)
594 {
595 uint32 msgLen = conn->outMsgEnd - conn->outMsgStart;
596
597 msgLen = pg_hton32(msgLen);
598 memcpy(conn->outBuffer + conn->outMsgStart, &msgLen, 4);
599 }
600
601 /* Make message eligible to send */
602 conn->outCount = conn->outMsgEnd;
603
604 if (conn->outCount >= 8192)
605 {
606 int toSend = conn->outCount - (conn->outCount % 8192);
607
608 if (pqSendSome(conn, toSend) < 0)
609 return EOF;
610 /* in nonblock mode, don't complain if unable to send it all */
611 }
612
613 return 0;
614 }
615
616 /* ----------
617 * pqReadData: read more data, if any is available
618 * Possible return values:
619 * 1: successfully loaded at least one more byte
620 * 0: no data is presently available, but no error detected
621 * -1: error detected (including EOF = connection closure);
622 * conn->errorMessage set
623 * NOTE: callers must not assume that pointers or indexes into conn->inBuffer
624 * remain valid across this call!
625 * ----------
626 */
627 int
pqReadData(PGconn * conn)628 pqReadData(PGconn *conn)
629 {
630 int someread = 0;
631 int nread;
632
633 if (conn->sock == PGINVALID_SOCKET)
634 {
635 printfPQExpBuffer(&conn->errorMessage,
636 libpq_gettext("connection not open\n"));
637 return -1;
638 }
639
640 /* Left-justify any data in the buffer to make room */
641 if (conn->inStart < conn->inEnd)
642 {
643 if (conn->inStart > 0)
644 {
645 memmove(conn->inBuffer, conn->inBuffer + conn->inStart,
646 conn->inEnd - conn->inStart);
647 conn->inEnd -= conn->inStart;
648 conn->inCursor -= conn->inStart;
649 conn->inStart = 0;
650 }
651 }
652 else
653 {
654 /* buffer is logically empty, reset it */
655 conn->inStart = conn->inCursor = conn->inEnd = 0;
656 }
657
658 /*
659 * If the buffer is fairly full, enlarge it. We need to be able to enlarge
660 * the buffer in case a single message exceeds the initial buffer size. We
661 * enlarge before filling the buffer entirely so as to avoid asking the
662 * kernel for a partial packet. The magic constant here should be large
663 * enough for a TCP packet or Unix pipe bufferload. 8K is the usual pipe
664 * buffer size, so...
665 */
666 if (conn->inBufSize - conn->inEnd < 8192)
667 {
668 if (pqCheckInBufferSpace(conn->inEnd + (size_t) 8192, conn))
669 {
670 /*
671 * We don't insist that the enlarge worked, but we need some room
672 */
673 if (conn->inBufSize - conn->inEnd < 100)
674 return -1; /* errorMessage already set */
675 }
676 }
677
678 /* OK, try to read some data */
679 retry3:
680 nread = pqsecure_read(conn, conn->inBuffer + conn->inEnd,
681 conn->inBufSize - conn->inEnd);
682 if (nread < 0)
683 {
684 if (SOCK_ERRNO == EINTR)
685 goto retry3;
686 /* Some systems return EAGAIN/EWOULDBLOCK for no data */
687 #ifdef EAGAIN
688 if (SOCK_ERRNO == EAGAIN)
689 return someread;
690 #endif
691 #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
692 if (SOCK_ERRNO == EWOULDBLOCK)
693 return someread;
694 #endif
695 /* We might get ECONNRESET here if using TCP and backend died */
696 #ifdef ECONNRESET
697 if (SOCK_ERRNO == ECONNRESET)
698 goto definitelyFailed;
699 #endif
700 /* pqsecure_read set the error message for us */
701 return -1;
702 }
703 if (nread > 0)
704 {
705 conn->inEnd += nread;
706
707 /*
708 * Hack to deal with the fact that some kernels will only give us back
709 * 1 packet per recv() call, even if we asked for more and there is
710 * more available. If it looks like we are reading a long message,
711 * loop back to recv() again immediately, until we run out of data or
712 * buffer space. Without this, the block-and-restart behavior of
713 * libpq's higher levels leads to O(N^2) performance on long messages.
714 *
715 * Since we left-justified the data above, conn->inEnd gives the
716 * amount of data already read in the current message. We consider
717 * the message "long" once we have acquired 32k ...
718 */
719 if (conn->inEnd > 32768 &&
720 (conn->inBufSize - conn->inEnd) >= 8192)
721 {
722 someread = 1;
723 goto retry3;
724 }
725 return 1;
726 }
727
728 if (someread)
729 return 1; /* got a zero read after successful tries */
730
731 /*
732 * A return value of 0 could mean just that no data is now available, or
733 * it could mean EOF --- that is, the server has closed the connection.
734 * Since we have the socket in nonblock mode, the only way to tell the
735 * difference is to see if select() is saying that the file is ready.
736 * Grumble. Fortunately, we don't expect this path to be taken much,
737 * since in normal practice we should not be trying to read data unless
738 * the file selected for reading already.
739 *
740 * In SSL mode it's even worse: SSL_read() could say WANT_READ and then
741 * data could arrive before we make the pqReadReady() test, but the second
742 * SSL_read() could still say WANT_READ because the data received was not
743 * a complete SSL record. So we must play dumb and assume there is more
744 * data, relying on the SSL layer to detect true EOF.
745 */
746
747 #ifdef USE_SSL
748 if (conn->ssl_in_use)
749 return 0;
750 #endif
751
752 switch (pqReadReady(conn))
753 {
754 case 0:
755 /* definitely no data available */
756 return 0;
757 case 1:
758 /* ready for read */
759 break;
760 default:
761 /* we override pqReadReady's message with something more useful */
762 goto definitelyEOF;
763 }
764
765 /*
766 * Still not sure that it's EOF, because some data could have just
767 * arrived.
768 */
769 retry4:
770 nread = pqsecure_read(conn, conn->inBuffer + conn->inEnd,
771 conn->inBufSize - conn->inEnd);
772 if (nread < 0)
773 {
774 if (SOCK_ERRNO == EINTR)
775 goto retry4;
776 /* Some systems return EAGAIN/EWOULDBLOCK for no data */
777 #ifdef EAGAIN
778 if (SOCK_ERRNO == EAGAIN)
779 return 0;
780 #endif
781 #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
782 if (SOCK_ERRNO == EWOULDBLOCK)
783 return 0;
784 #endif
785 /* We might get ECONNRESET here if using TCP and backend died */
786 #ifdef ECONNRESET
787 if (SOCK_ERRNO == ECONNRESET)
788 goto definitelyFailed;
789 #endif
790 /* pqsecure_read set the error message for us */
791 return -1;
792 }
793 if (nread > 0)
794 {
795 conn->inEnd += nread;
796 return 1;
797 }
798
799 /*
800 * OK, we are getting a zero read even though select() says ready. This
801 * means the connection has been closed. Cope.
802 */
803 definitelyEOF:
804 printfPQExpBuffer(&conn->errorMessage,
805 libpq_gettext("server closed the connection unexpectedly\n"
806 "\tThis probably means the server terminated abnormally\n"
807 "\tbefore or while processing the request.\n"));
808
809 /* Come here if lower-level code already set a suitable errorMessage */
810 definitelyFailed:
811 /* Do *not* drop any already-read data; caller still wants it */
812 pqDropConnection(conn, false);
813 conn->status = CONNECTION_BAD; /* No more connection to backend */
814 return -1;
815 }
816
817 /*
818 * pqSendSome: send data waiting in the output buffer.
819 *
820 * len is how much to try to send (typically equal to outCount, but may
821 * be less).
822 *
823 * Return 0 on success, -1 on failure and 1 when not all data could be sent
824 * because the socket would block and the connection is non-blocking.
825 *
826 * Note that this is also responsible for consuming data from the socket
827 * (putting it in conn->inBuffer) in any situation where we can't send
828 * all the specified data immediately.
829 *
830 * Upon write failure, conn->write_failed is set and the error message is
831 * saved in conn->write_err_msg, but we clear the output buffer and return
832 * zero anyway; this is because callers should soldier on until it's possible
833 * to read from the server and check for an error message. write_err_msg
834 * should be reported only when we are unable to obtain a server error first.
835 * (Thus, a -1 result is returned only for an internal *read* failure.)
836 */
837 static int
pqSendSome(PGconn * conn,int len)838 pqSendSome(PGconn *conn, int len)
839 {
840 char *ptr = conn->outBuffer;
841 int remaining = conn->outCount;
842 int result = 0;
843
844 /*
845 * If we already had a write failure, we will never again try to send data
846 * on that connection. Even if the kernel would let us, we've probably
847 * lost message boundary sync with the server. conn->write_failed
848 * therefore persists until the connection is reset, and we just discard
849 * all data presented to be written. However, as long as we still have a
850 * valid socket, we should continue to absorb data from the backend, so
851 * that we can collect any final error messages.
852 */
853 if (conn->write_failed)
854 {
855 /* conn->write_err_msg should be set up already */
856 conn->outCount = 0;
857 /* Absorb input data if any, and detect socket closure */
858 if (conn->sock != PGINVALID_SOCKET)
859 {
860 if (pqReadData(conn) < 0)
861 return -1;
862 }
863 return 0;
864 }
865
866 if (conn->sock == PGINVALID_SOCKET)
867 {
868 printfPQExpBuffer(&conn->errorMessage,
869 libpq_gettext("connection not open\n"));
870 conn->write_failed = true;
871 /* Transfer error message to conn->write_err_msg, if possible */
872 /* (strdup failure is OK, we'll cope later) */
873 conn->write_err_msg = strdup(conn->errorMessage.data);
874 resetPQExpBuffer(&conn->errorMessage);
875 /* Discard queued data; no chance it'll ever be sent */
876 conn->outCount = 0;
877 return 0;
878 }
879
880 /* while there's still data to send */
881 while (len > 0)
882 {
883 int sent;
884
885 #ifndef WIN32
886 sent = pqsecure_write(conn, ptr, len);
887 #else
888
889 /*
890 * Windows can fail on large sends, per KB article Q201213. The
891 * failure-point appears to be different in different versions of
892 * Windows, but 64k should always be safe.
893 */
894 sent = pqsecure_write(conn, ptr, Min(len, 65536));
895 #endif
896
897 if (sent < 0)
898 {
899 /* Anything except EAGAIN/EWOULDBLOCK/EINTR is trouble */
900 switch (SOCK_ERRNO)
901 {
902 #ifdef EAGAIN
903 case EAGAIN:
904 break;
905 #endif
906 #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
907 case EWOULDBLOCK:
908 break;
909 #endif
910 case EINTR:
911 continue;
912
913 default:
914 /* pqsecure_write set the error message for us */
915 conn->write_failed = true;
916
917 /*
918 * Transfer error message to conn->write_err_msg, if
919 * possible (strdup failure is OK, we'll cope later).
920 *
921 * Note: this assumes that pqsecure_write and its children
922 * will overwrite not append to conn->errorMessage. If
923 * that's ever changed, we could remember the length of
924 * conn->errorMessage at entry to this routine, and then
925 * save and delete just what was appended.
926 */
927 conn->write_err_msg = strdup(conn->errorMessage.data);
928 resetPQExpBuffer(&conn->errorMessage);
929
930 /* Discard queued data; no chance it'll ever be sent */
931 conn->outCount = 0;
932
933 /* Absorb input data if any, and detect socket closure */
934 if (conn->sock != PGINVALID_SOCKET)
935 {
936 if (pqReadData(conn) < 0)
937 return -1;
938 }
939 return 0;
940 }
941 }
942 else
943 {
944 ptr += sent;
945 len -= sent;
946 remaining -= sent;
947 }
948
949 if (len > 0)
950 {
951 /*
952 * We didn't send it all, wait till we can send more.
953 *
954 * There are scenarios in which we can't send data because the
955 * communications channel is full, but we cannot expect the server
956 * to clear the channel eventually because it's blocked trying to
957 * send data to us. (This can happen when we are sending a large
958 * amount of COPY data, and the server has generated lots of
959 * NOTICE responses.) To avoid a deadlock situation, we must be
960 * prepared to accept and buffer incoming data before we try
961 * again. Furthermore, it is possible that such incoming data
962 * might not arrive until after we've gone to sleep. Therefore,
963 * we wait for either read ready or write ready.
964 *
965 * In non-blocking mode, we don't wait here directly, but return 1
966 * to indicate that data is still pending. The caller should wait
967 * for both read and write ready conditions, and call
968 * PQconsumeInput() on read ready, but just in case it doesn't, we
969 * call pqReadData() ourselves before returning. That's not
970 * enough if the data has not arrived yet, but it's the best we
971 * can do, and works pretty well in practice. (The documentation
972 * used to say that you only need to wait for write-ready, so
973 * there are still plenty of applications like that out there.)
974 *
975 * Note that errors here don't result in write_failed becoming
976 * set.
977 */
978 if (pqReadData(conn) < 0)
979 {
980 result = -1; /* error message already set up */
981 break;
982 }
983
984 if (pqIsnonblocking(conn))
985 {
986 result = 1;
987 break;
988 }
989
990 if (pqWait(true, true, conn))
991 {
992 result = -1;
993 break;
994 }
995 }
996 }
997
998 /* shift the remaining contents of the buffer */
999 if (remaining > 0)
1000 memmove(conn->outBuffer, ptr, remaining);
1001 conn->outCount = remaining;
1002
1003 return result;
1004 }
1005
1006
1007 /*
1008 * pqFlush: send any data waiting in the output buffer
1009 *
1010 * Return 0 on success, -1 on failure and 1 when not all data could be sent
1011 * because the socket would block and the connection is non-blocking.
1012 * (See pqSendSome comments about how failure should be handled.)
1013 */
1014 int
pqFlush(PGconn * conn)1015 pqFlush(PGconn *conn)
1016 {
1017 if (conn->Pfdebug)
1018 fflush(conn->Pfdebug);
1019
1020 if (conn->outCount > 0)
1021 return pqSendSome(conn, conn->outCount);
1022
1023 return 0;
1024 }
1025
1026
1027 /*
1028 * pqWait: wait until we can read or write the connection socket
1029 *
1030 * JAB: If SSL enabled and used and forRead, buffered bytes short-circuit the
1031 * call to select().
1032 *
1033 * We also stop waiting and return if the kernel flags an exception condition
1034 * on the socket. The actual error condition will be detected and reported
1035 * when the caller tries to read or write the socket.
1036 */
1037 int
pqWait(int forRead,int forWrite,PGconn * conn)1038 pqWait(int forRead, int forWrite, PGconn *conn)
1039 {
1040 return pqWaitTimed(forRead, forWrite, conn, (time_t) -1);
1041 }
1042
1043 /*
1044 * pqWaitTimed: wait, but not past finish_time.
1045 *
1046 * finish_time = ((time_t) -1) disables the wait limit.
1047 *
1048 * Returns -1 on failure, 0 if the socket is readable/writable, 1 if it timed out.
1049 */
1050 int
pqWaitTimed(int forRead,int forWrite,PGconn * conn,time_t finish_time)1051 pqWaitTimed(int forRead, int forWrite, PGconn *conn, time_t finish_time)
1052 {
1053 int result;
1054
1055 result = pqSocketCheck(conn, forRead, forWrite, finish_time);
1056
1057 if (result < 0)
1058 return -1; /* errorMessage is already set */
1059
1060 if (result == 0)
1061 {
1062 printfPQExpBuffer(&conn->errorMessage,
1063 libpq_gettext("timeout expired\n"));
1064 return 1;
1065 }
1066
1067 return 0;
1068 }
1069
1070 /*
1071 * pqReadReady: is select() saying the file is ready to read?
1072 * Returns -1 on failure, 0 if not ready, 1 if ready.
1073 */
1074 int
pqReadReady(PGconn * conn)1075 pqReadReady(PGconn *conn)
1076 {
1077 return pqSocketCheck(conn, 1, 0, (time_t) 0);
1078 }
1079
1080 /*
1081 * pqWriteReady: is select() saying the file is ready to write?
1082 * Returns -1 on failure, 0 if not ready, 1 if ready.
1083 */
1084 int
pqWriteReady(PGconn * conn)1085 pqWriteReady(PGconn *conn)
1086 {
1087 return pqSocketCheck(conn, 0, 1, (time_t) 0);
1088 }
1089
1090 /*
1091 * Checks a socket, using poll or select, for data to be read, written,
1092 * or both. Returns >0 if one or more conditions are met, 0 if it timed
1093 * out, -1 if an error occurred.
1094 *
1095 * If SSL is in use, the SSL buffer is checked prior to checking the socket
1096 * for read data directly.
1097 */
1098 static int
pqSocketCheck(PGconn * conn,int forRead,int forWrite,time_t end_time)1099 pqSocketCheck(PGconn *conn, int forRead, int forWrite, time_t end_time)
1100 {
1101 int result;
1102
1103 if (!conn)
1104 return -1;
1105 if (conn->sock == PGINVALID_SOCKET)
1106 {
1107 printfPQExpBuffer(&conn->errorMessage,
1108 libpq_gettext("invalid socket\n"));
1109 return -1;
1110 }
1111
1112 #ifdef USE_SSL
1113 /* Check for SSL library buffering read bytes */
1114 if (forRead && conn->ssl_in_use && pgtls_read_pending(conn))
1115 {
1116 /* short-circuit the select */
1117 return 1;
1118 }
1119 #endif
1120
1121 /* We will retry as long as we get EINTR */
1122 do
1123 result = pqSocketPoll(conn->sock, forRead, forWrite, end_time);
1124 while (result < 0 && SOCK_ERRNO == EINTR);
1125
1126 if (result < 0)
1127 {
1128 char sebuf[PG_STRERROR_R_BUFLEN];
1129
1130 printfPQExpBuffer(&conn->errorMessage,
1131 libpq_gettext("select() failed: %s\n"),
1132 SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
1133 }
1134
1135 return result;
1136 }
1137
1138
1139 /*
1140 * Check a file descriptor for read and/or write data, possibly waiting.
1141 * If neither forRead nor forWrite are set, immediately return a timeout
1142 * condition (without waiting). Return >0 if condition is met, 0
1143 * if a timeout occurred, -1 if an error or interrupt occurred.
1144 *
1145 * Timeout is infinite if end_time is -1. Timeout is immediate (no blocking)
1146 * if end_time is 0 (or indeed, any time before now).
1147 */
1148 static int
pqSocketPoll(int sock,int forRead,int forWrite,time_t end_time)1149 pqSocketPoll(int sock, int forRead, int forWrite, time_t end_time)
1150 {
1151 /* We use poll(2) if available, otherwise select(2) */
1152 #ifdef HAVE_POLL
1153 struct pollfd input_fd;
1154 int timeout_ms;
1155
1156 if (!forRead && !forWrite)
1157 return 0;
1158
1159 input_fd.fd = sock;
1160 input_fd.events = POLLERR;
1161 input_fd.revents = 0;
1162
1163 if (forRead)
1164 input_fd.events |= POLLIN;
1165 if (forWrite)
1166 input_fd.events |= POLLOUT;
1167
1168 /* Compute appropriate timeout interval */
1169 if (end_time == ((time_t) -1))
1170 timeout_ms = -1;
1171 else
1172 {
1173 time_t now = time(NULL);
1174
1175 if (end_time > now)
1176 timeout_ms = (end_time - now) * 1000;
1177 else
1178 timeout_ms = 0;
1179 }
1180
1181 return poll(&input_fd, 1, timeout_ms);
1182 #else /* !HAVE_POLL */
1183
1184 fd_set input_mask;
1185 fd_set output_mask;
1186 fd_set except_mask;
1187 struct timeval timeout;
1188 struct timeval *ptr_timeout;
1189
1190 if (!forRead && !forWrite)
1191 return 0;
1192
1193 FD_ZERO(&input_mask);
1194 FD_ZERO(&output_mask);
1195 FD_ZERO(&except_mask);
1196 if (forRead)
1197 FD_SET(sock, &input_mask);
1198
1199 if (forWrite)
1200 FD_SET(sock, &output_mask);
1201 FD_SET(sock, &except_mask);
1202
1203 /* Compute appropriate timeout interval */
1204 if (end_time == ((time_t) -1))
1205 ptr_timeout = NULL;
1206 else
1207 {
1208 time_t now = time(NULL);
1209
1210 if (end_time > now)
1211 timeout.tv_sec = end_time - now;
1212 else
1213 timeout.tv_sec = 0;
1214 timeout.tv_usec = 0;
1215 ptr_timeout = &timeout;
1216 }
1217
1218 return select(sock + 1, &input_mask, &output_mask,
1219 &except_mask, ptr_timeout);
1220 #endif /* HAVE_POLL */
1221 }
1222
1223
1224 /*
1225 * A couple of "miscellaneous" multibyte related functions. They used
1226 * to be in fe-print.c but that file is doomed.
1227 */
1228
1229 /*
1230 * returns the byte length of the character beginning at s, using the
1231 * specified encoding.
1232 */
1233 int
PQmblen(const char * s,int encoding)1234 PQmblen(const char *s, int encoding)
1235 {
1236 return pg_encoding_mblen(encoding, s);
1237 }
1238
1239 /*
1240 * returns the display length of the character beginning at s, using the
1241 * specified encoding.
1242 */
1243 int
PQdsplen(const char * s,int encoding)1244 PQdsplen(const char *s, int encoding)
1245 {
1246 return pg_encoding_dsplen(encoding, s);
1247 }
1248
1249 /*
1250 * Get encoding id from environment variable PGCLIENTENCODING.
1251 */
1252 int
PQenv2encoding(void)1253 PQenv2encoding(void)
1254 {
1255 char *str;
1256 int encoding = PG_SQL_ASCII;
1257
1258 str = getenv("PGCLIENTENCODING");
1259 if (str && *str != '\0')
1260 {
1261 encoding = pg_char_to_encoding(str);
1262 if (encoding < 0)
1263 encoding = PG_SQL_ASCII;
1264 }
1265 return encoding;
1266 }
1267
1268
1269 #ifdef ENABLE_NLS
1270
1271 static void
libpq_binddomain(void)1272 libpq_binddomain(void)
1273 {
1274 static bool already_bound = false;
1275
1276 if (!already_bound)
1277 {
1278 /* bindtextdomain() does not preserve errno */
1279 #ifdef WIN32
1280 int save_errno = GetLastError();
1281 #else
1282 int save_errno = errno;
1283 #endif
1284 const char *ldir;
1285
1286 already_bound = true;
1287 /* No relocatable lookup here because the binary could be anywhere */
1288 ldir = getenv("PGLOCALEDIR");
1289 if (!ldir)
1290 ldir = LOCALEDIR;
1291 bindtextdomain(PG_TEXTDOMAIN("libpq"), ldir);
1292 #ifdef WIN32
1293 SetLastError(save_errno);
1294 #else
1295 errno = save_errno;
1296 #endif
1297 }
1298 }
1299
1300 char *
libpq_gettext(const char * msgid)1301 libpq_gettext(const char *msgid)
1302 {
1303 libpq_binddomain();
1304 return dgettext(PG_TEXTDOMAIN("libpq"), msgid);
1305 }
1306
1307 char *
libpq_ngettext(const char * msgid,const char * msgid_plural,unsigned long n)1308 libpq_ngettext(const char *msgid, const char *msgid_plural, unsigned long n)
1309 {
1310 libpq_binddomain();
1311 return dngettext(PG_TEXTDOMAIN("libpq"), msgid, msgid_plural, n);
1312 }
1313
1314 #endif /* ENABLE_NLS */
1315