2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of John Walker.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
29 * Network Utility Routines
33 * Adapted and enhanced for Bacula, originally written
34 * for inclusion in the Apcupsd package
44 extern time_t watchdog_time;
47 #define INADDR_NONE -1
51 #define socketRead(fd, buf, len) recv(fd, buf, len, 0)
52 #define socketWrite(fd, buf, len) send(fd, buf, len, 0)
53 #define socketClose(fd) closesocket(fd)
55 #define socketRead(fd, buf, len) read(fd, buf, len)
56 #define socketWrite(fd, buf, len) write(fd, buf, len)
57 #define socketClose(fd) close(fd)
60 static pthread_mutex_t ip_mutex = PTHREAD_MUTEX_INITIALIZER;
63 * Read a nbytes from the network.
64 * It is possible that the total bytes require in several
68 int32_t read_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
75 return (tls_bsock_readn(bsock, ptr, nbytes));
82 nread = socketRead(bsock->m_fd, ptr, nleft);
83 if (bsock->is_timed_out() || bsock->is_terminated()) {
90 if (errno == EAGAIN) {
91 bmicrosleep(0, 200000); /* try again in 200ms */
96 return nread; /* error, or EOF */
101 return nbytes - nleft; /* return >= 0 */
105 * Write nbytes to the network.
106 * It may require several writes.
109 int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
111 int32_t nleft, nwritten;
113 if (bsock->is_spooling()) {
114 nwritten = fwrite(ptr, 1, nbytes, bsock->m_spool_fd);
115 if (nwritten != nbytes) {
117 bsock->b_errno = errno;
118 Qmsg1(bsock->jcr(), M_FATAL, 0, _("Attr spool write error. ERR=%s\n"),
120 Dmsg2(400, "nwritten=%d nbytes=%d.\n", nwritten, nbytes);
121 errno = bsock->b_errno;
130 return (tls_bsock_writen(bsock, ptr, nbytes));
132 #endif /* HAVE_TLS */
138 nwritten = socketWrite(bsock->m_fd, ptr, nleft);
139 if (bsock->is_timed_out() || bsock->is_terminated()) {
142 } while (nwritten == -1 && errno == EINTR);
144 * If connection is non-blocking, we will get EAGAIN, so
145 * use select() to keep from consuming all the CPU
148 if (nwritten == -1 && errno == EAGAIN) {
153 FD_SET((unsigned)bsock->m_fd, &fdset);
156 select(bsock->m_fd + 1, NULL, &fdset, NULL, &tv);
160 return nwritten; /* error */
165 return nbytes - nleft;
169 * Receive a message from the other end. Each message consists of
170 * two packets. The first is a header that contains the size
171 * of the data that follows in the second packet.
172 * Returns number of bytes read (may return zero)
173 * Returns -1 on signal (BNET_SIGNAL)
174 * Returns -2 on hard end of file (BNET_HARDEOF)
175 * Returns -3 on error (BNET_ERROR)
177 * Unfortunately, it is a bit complicated because we have these
180 * 2. Signal including end of data stream
181 * 3. Hard end of file
183 * Using is_bnet_stop() and is_bnet_error() you can figure this all out.
185 int32_t bnet_recv(BSOCK * bsock)
187 return bsock->recv();
192 * Return 1 if there are errors on this bsock or it is closed,
193 * i.e. stop communicating on this line.
195 bool is_bnet_stop(BSOCK * bsock)
197 return bsock->errors || bsock->is_terminated();
201 * Return number of errors on socket
203 int is_bnet_error(BSOCK * bsock)
205 errno = bsock->b_errno;
206 return bsock->errors;
210 * Call here after error during closing to suppress error
211 * messages which are due to the other end shutting down too.
213 void bnet_suppress_error_messages(BSOCK * bsock, bool flag)
215 bsock->m_suppress_error_msgs = flag;
219 * Send a message over the network. The send consists of
220 * two network packets. The first is sends a 32 bit integer containing
221 * the length of the data packet which follows.
223 * Returns: false on failure
226 bool bnet_send(BSOCK *bsock)
228 return bsock->send();
233 * Establish a TLS connection -- server side
234 * Returns: true on success
238 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
241 JCR *jcr = bsock->jcr();
243 tls = new_tls_connection(ctx, bsock->m_fd);
245 Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
251 /* Initiate TLS Negotiation */
252 if (!tls_bsock_accept(bsock)) {
253 Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS Negotiation failed.\n"));
258 if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
259 Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
260 " Peer certificate did not match a required commonName\n"),
265 Dmsg0(50, "TLS server negotiation established.\n");
269 free_tls_connection(tls);
275 * Establish a TLS connection -- client side
276 * Returns: true on success
279 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
282 JCR *jcr = bsock->jcr();
284 tls = new_tls_connection(ctx, bsock->m_fd);
286 Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
292 /* Initiate TLS Negotiation */
293 if (!tls_bsock_connect(bsock)) {
297 /* If there's an Allowed CN verify list, use that to validate the remote
298 * certificate's CN. Otherwise, we use standard host/CN matching. */
300 if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
301 Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
302 " Peer certificate did not match a required commonName\n"),
307 if (!tls_postconnect_verify_host(jcr, tls, bsock->host())) {
308 Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host name \"%s\" did not match presented certificate\n"),
313 Dmsg0(50, "TLS client negotiation established.\n");
317 free_tls_connection(tls);
323 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
325 Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n"));
329 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
331 Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n"));
335 #endif /* HAVE_TLS */
338 * Wait for a specified time for data to appear on
339 * the BSOCK connection.
341 * Returns: 1 if data available
345 int bnet_wait_data(BSOCK * bsock, int sec)
347 return bsock->wait_data(sec);
351 * As above, but returns on interrupt
353 int bnet_wait_data_intr(BSOCK * bsock, int sec)
355 return bsock->wait_data_intr(sec);
358 #ifndef NETDB_INTERNAL
359 #define NETDB_INTERNAL -1 /* See errno. */
361 #ifndef NETDB_SUCCESS
362 #define NETDB_SUCCESS 0 /* No problem. */
364 #ifndef HOST_NOT_FOUND
365 #define HOST_NOT_FOUND 1 /* Authoritative Answer Host not found. */
368 #define TRY_AGAIN 2 /* Non-Authoritative Host not found, or SERVERFAIL. */
371 #define NO_RECOVERY 3 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
374 #define NO_DATA 4 /* Valid name, no data record of requested type. */
378 * Get human readable error for gethostbyname()
380 static const char *gethost_strerror()
386 msg = be.bstrerror();
389 msg = _("No problem.");
392 msg = _("Authoritative answer for host not found.");
395 msg = _("Non-authoritative for host not found, or ServerFail.");
398 msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
401 msg = _("Valid name, no data record of resquested type.");
404 msg = _("Unknown error.");
412 static IPADDR *add_any(int family)
414 IPADDR *addr = New(IPADDR(family));
415 addr->set_type(IPADDR::R_MULTIPLE);
416 addr->set_addr_any();
420 static const char *resolv_host(int family, const char *host, dlist * addr_list)
425 P(ip_mutex); /* gethostbyname() is not thread safe */
426 #ifdef HAVE_GETHOSTBYNAME2
427 if ((hp = gethostbyname2(host, family)) == NULL) {
429 if ((hp = gethostbyname(host)) == NULL) {
431 /* may be the strerror give not the right result -:( */
432 errmsg = gethost_strerror();
437 for (p = hp->h_addr_list; *p != 0; p++) {
438 IPADDR *addr = New(IPADDR(hp->h_addrtype));
439 addr->set_type(IPADDR::R_MULTIPLE);
440 if (addr->get_family() == AF_INET) {
441 addr->set_addr4((struct in_addr*)*p);
445 addr->set_addr6((struct in6_addr*)*p);
448 addr_list->append(addr);
456 * i host = 0 mean INADDR_ANY only ipv4
458 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
460 struct in_addr inaddr;
464 struct in6_addr inaddr6;
467 dlist *addr_list = New(dlist(addr, &addr->link));
468 if (!host || host[0] == '\0') {
470 addr_list->append(add_any(family));
472 addr_list->append(add_any(AF_INET));
474 addr_list->append(add_any(AF_INET6));
477 } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
478 addr = New(IPADDR(AF_INET));
479 addr->set_type(IPADDR::R_MULTIPLE);
480 addr->set_addr4(&inaddr);
481 addr_list->append(addr);
484 if (inet_pton(AF_INET6, host, &inaddr6) > 1) {
485 addr = New(IPADDR(AF_INET6));
486 addr->set_type(IPADDR::R_MULTIPLE);
487 addr->set_addr6(&inaddr6);
488 addr_list->append(addr);
493 errmsg = resolv_host(family, host, addr_list);
496 free_addresses(addr_list);
500 errmsg = resolv_host(AF_INET, host, addr_list);
503 errmsg = resolv_host(AF_INET6, host, addr_list);
508 free_addresses(addr_list);
517 * This is the "old" way of opening a connection. The preferred way is
518 * now to do what this subroutine does, but inline. That allows the
519 * connect() call to return error status, ...
521 BSOCK *bnet_connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
523 const char *name, char *host, char *service, int port,
526 BSOCK *bsock = new_bsock();
527 if (!bsock->connect(jcr, retry_interval, max_retry_time, heart_beat,
528 name, host, service, port, verbose)) {
538 * Return the string for the error that occurred
539 * on the socket. Only the first error is retained.
541 const char *bnet_strerror(BSOCK * bsock)
543 return bsock->bstrerror();
547 * Format and send a message
548 * Returns: false on error
551 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
556 if (bs->errors || bs->is_terminated()) {
559 /* This probably won't work, but we vsnprintf, then if we
560 * get a negative length or a length greater than our buffer
561 * (depending on which library is used), the printf was truncated, so
562 * get a bigger buffer and try again.
565 maxlen = sizeof_pool_memory(bs->msg) - 1;
566 va_start(arg_ptr, fmt);
567 bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
569 if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
572 bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
577 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen)
579 return bs->get_peer(buf, buflen);
583 * Set the network buffer size, suggested size is in size.
584 * Actual size obtained is returned in bs->msglen
586 * Returns: 0 on failure
589 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
591 return bs->set_buffer_size(size, rw);
595 * Set socket non-blocking
596 * Returns previous socket flag
598 int bnet_set_nonblocking(BSOCK *bsock)
600 return bsock->set_nonblocking();
604 * Set socket blocking
605 * Returns previous socket flags
607 int bnet_set_blocking(BSOCK *bsock)
609 return bsock->set_blocking();
613 * Restores socket flags
615 void bnet_restore_blocking (BSOCK *bsock, int flags)
617 bsock->restore_blocking(flags);
622 * Send a network "signal" to the other end
623 * This consists of sending a negative packet length
625 * Returns: false on failure
628 bool bnet_sig(BSOCK * bs, int signal)
630 return bs->signal(signal);
634 * Convert a network "signal" code into
635 * human readable ASCII.
637 const char *bnet_sig_to_ascii(BSOCK * bs)
640 switch (bs->msglen) {
642 return "BNET_EOD"; /* end of data stream */
644 return "BNET_EOD_POLL";
646 return "BNET_STATUS";
648 return "BNET_TERMINATE"; /* terminate connection */
652 return "BNET_HEARTBEAT";
653 case BNET_HB_RESPONSE:
654 return "BNET_HB_RESPONSE";
656 return "BNET_PROMPT";
658 sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
663 /* Initialize internal socket structure.
664 * This probably should be done in net_open
666 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
667 struct sockaddr *client_addr)
669 Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
670 BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
671 memset(bsock, 0, sizeof(BSOCK));
672 bsock->m_fd = sockfd;
675 bsock->m_blocking = 1;
676 bsock->msg = get_pool_memory(PM_MESSAGE);
677 bsock->errmsg = get_pool_memory(PM_MESSAGE);
678 bsock->set_who(bstrdup(who));
679 bsock->set_host(bstrdup(host));
680 bsock->set_port(port);
681 memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
682 memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
684 * ****FIXME**** reduce this to a few hours once
685 * heartbeats are implemented
687 bsock->timeout = 60 * 60 * 6 * 24; /* 6 days timeout */
692 BSOCK *dup_bsock(BSOCK *osock)
694 BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
695 memcpy(bsock, osock, sizeof(BSOCK));
696 bsock->msg = get_pool_memory(PM_MESSAGE);
697 bsock->errmsg = get_pool_memory(PM_MESSAGE);
699 bsock->set_who(bstrdup(osock->who()));
702 bsock->set_host(bstrdup(osock->host()));
708 /* Close the network connection */
709 void bnet_close(BSOCK * bsock)
714 void term_bsock(BSOCK * bsock)