PostgreSQL Source Code git master
ip.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * ip.c
4 * IPv6-aware network access.
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/common/ip.c
12 *
13 * This file and the IPV6 implementation were initially provided by
14 * Nigel Kukard <nkukard@lbsd.net>, Linux Based Systems Design
15 * http://www.lbsd.net.
16 *
17 *-------------------------------------------------------------------------
18 */
19
20#ifndef FRONTEND
21#include "postgres.h"
22#else
23#include "postgres_fe.h"
24#endif
25
26#include <unistd.h>
27#include <sys/stat.h>
28#include <sys/socket.h>
29#include <netdb.h>
30#include <netinet/in.h>
31#include <netinet/tcp.h>
32#include <arpa/inet.h>
33#include <sys/file.h>
34
35#include "common/ip.h"
36
37
38
39static int getaddrinfo_unix(const char *path,
40 const struct addrinfo *hintsp,
41 struct addrinfo **result);
42
43static int getnameinfo_unix(const struct sockaddr_un *sa, int salen,
44 char *node, int nodelen,
45 char *service, int servicelen,
46 int flags);
47
48
49/*
50 * pg_getaddrinfo_all - get address info for Unix, IPv4 and IPv6 sockets
51 */
52int
53pg_getaddrinfo_all(const char *hostname, const char *servname,
54 const struct addrinfo *hintp, struct addrinfo **result)
55{
56 int rc;
57
58 /* not all versions of getaddrinfo() zero *result on failure */
59 *result = NULL;
60
61 if (hintp->ai_family == AF_UNIX)
62 return getaddrinfo_unix(servname, hintp, result);
63
64 /* NULL has special meaning to getaddrinfo(). */
65 rc = getaddrinfo((!hostname || hostname[0] == '\0') ? NULL : hostname,
66 servname, hintp, result);
67
68 return rc;
69}
70
71
72/*
73 * pg_freeaddrinfo_all - free addrinfo structures for IPv4, IPv6, or Unix
74 *
75 * Note: the ai_family field of the original hint structure must be passed
76 * so that we can tell whether the addrinfo struct was built by the system's
77 * getaddrinfo() routine or our own getaddrinfo_unix() routine. Some versions
78 * of getaddrinfo() might be willing to return AF_UNIX addresses, so it's
79 * not safe to look at ai_family in the addrinfo itself.
80 */
81void
82pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo *ai)
83{
84 if (hint_ai_family == AF_UNIX)
85 {
86 /* struct was built by getaddrinfo_unix (see pg_getaddrinfo_all) */
87 while (ai != NULL)
88 {
89 struct addrinfo *p = ai;
90
91 ai = ai->ai_next;
92 free(p->ai_addr);
93 free(p);
94 }
95 }
96 else
97 {
98 /* struct was built by getaddrinfo() */
99 if (ai != NULL)
100 freeaddrinfo(ai);
101 }
102}
103
104
105/*
106 * pg_getnameinfo_all - get name info for Unix, IPv4 and IPv6 sockets
107 *
108 * The API of this routine differs from the standard getnameinfo() definition
109 * in two ways: first, the addr parameter is declared as sockaddr_storage
110 * rather than struct sockaddr, and second, the node and service fields are
111 * guaranteed to be filled with something even on failure return.
112 */
113int
114pg_getnameinfo_all(const struct sockaddr_storage *addr, int salen,
115 char *node, int nodelen,
116 char *service, int servicelen,
117 int flags)
118{
119 int rc;
120
121 if (addr && addr->ss_family == AF_UNIX)
122 rc = getnameinfo_unix((const struct sockaddr_un *) addr, salen,
123 node, nodelen,
124 service, servicelen,
125 flags);
126 else
127 rc = getnameinfo((const struct sockaddr *) addr, salen,
128 node, nodelen,
129 service, servicelen,
130 flags);
131
132 if (rc != 0)
133 {
134 if (node)
135 strlcpy(node, "???", nodelen);
136 if (service)
137 strlcpy(service, "???", servicelen);
138 }
139
140 return rc;
141}
142
143
144/* -------
145 * getaddrinfo_unix - get unix socket info using IPv6-compatible API
146 *
147 * Bugs: only one addrinfo is set even though hintsp is NULL or
148 * ai_socktype is 0
149 * AI_CANONNAME is not supported.
150 * -------
151 */
152static int
153getaddrinfo_unix(const char *path, const struct addrinfo *hintsp,
154 struct addrinfo **result)
155{
156 struct addrinfo hints = {0};
157 struct addrinfo *aip;
158 struct sockaddr_un *unp;
159
160 *result = NULL;
161
162 if (strlen(path) >= sizeof(unp->sun_path))
163 return EAI_FAIL;
164
165 if (hintsp == NULL)
166 {
167 hints.ai_family = AF_UNIX;
168 hints.ai_socktype = SOCK_STREAM;
169 }
170 else
171 memcpy(&hints, hintsp, sizeof(hints));
172
173 if (hints.ai_socktype == 0)
174 hints.ai_socktype = SOCK_STREAM;
175
176 if (hints.ai_family != AF_UNIX)
177 {
178 /* shouldn't have been called */
179 return EAI_FAIL;
180 }
181
182 aip = calloc(1, sizeof(struct addrinfo));
183 if (aip == NULL)
184 return EAI_MEMORY;
185
186 unp = calloc(1, sizeof(struct sockaddr_un));
187 if (unp == NULL)
188 {
189 free(aip);
190 return EAI_MEMORY;
191 }
192
193 aip->ai_family = AF_UNIX;
194 aip->ai_socktype = hints.ai_socktype;
195 aip->ai_protocol = hints.ai_protocol;
196 aip->ai_next = NULL;
197 aip->ai_canonname = NULL;
198 *result = aip;
199
200 unp->sun_family = AF_UNIX;
201 aip->ai_addr = (struct sockaddr *) unp;
202 aip->ai_addrlen = sizeof(struct sockaddr_un);
203
204 strcpy(unp->sun_path, path);
205
206 /*
207 * If the supplied path starts with @, replace that with a zero byte for
208 * the internal representation. In that mode, the entire sun_path is the
209 * address, including trailing zero bytes. But we set the address length
210 * to only include the length of the original string. That way the
211 * trailing zero bytes won't show up in any network or socket lists of the
212 * operating system. This is just a convention, also followed by other
213 * packages.
214 */
215 if (path[0] == '@')
216 {
217 unp->sun_path[0] = '\0';
218 aip->ai_addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(path);
219 }
220
221 return 0;
222}
223
224/*
225 * Convert an address to a hostname.
226 */
227static int
228getnameinfo_unix(const struct sockaddr_un *sa, int salen,
229 char *node, int nodelen,
230 char *service, int servicelen,
231 int flags)
232{
233 int ret;
234
235 /* Invalid arguments. */
236 if (sa == NULL || sa->sun_family != AF_UNIX ||
237 (node == NULL && service == NULL))
238 return EAI_FAIL;
239
240 if (node)
241 {
242 ret = snprintf(node, nodelen, "%s", "[local]");
243 if (ret < 0 || ret >= nodelen)
244 return EAI_MEMORY;
245 }
246
247 if (service)
248 {
249 /*
250 * Check whether it looks like an abstract socket, but it could also
251 * just be an empty string.
252 */
253 if (sa->sun_path[0] == '\0' && sa->sun_path[1] != '\0')
254 ret = snprintf(service, servicelen, "@%s", sa->sun_path + 1);
255 else
256 ret = snprintf(service, servicelen, "%s", sa->sun_path);
257 if (ret < 0 || ret >= servicelen)
258 return EAI_MEMORY;
259 }
260
261 return 0;
262}
#define calloc(a, b)
Definition: header.h:55
#define free(a)
Definition: header.h:65
void pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo *ai)
Definition: ip.c:82
int pg_getnameinfo_all(const struct sockaddr_storage *addr, int salen, char *node, int nodelen, char *service, int servicelen, int flags)
Definition: ip.c:114
static int getnameinfo_unix(const struct sockaddr_un *sa, int salen, char *node, int nodelen, char *service, int servicelen, int flags)
Definition: ip.c:228
static int getaddrinfo_unix(const char *path, const struct addrinfo *hintsp, struct addrinfo **result)
Definition: ip.c:153
int pg_getaddrinfo_all(const char *hostname, const char *servname, const struct addrinfo *hintp, struct addrinfo **result)
Definition: ip.c:53
static char * hostname
Definition: pg_regress.c:114
#define snprintf
Definition: port.h:239
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
Definition: un.h:12
unsigned short sun_family
Definition: un.h:13
char sun_path[108]
Definition: un.h:14