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 Kern Sibbald.
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
45 #define INADDR_NONE -1
49 #define socketRead(fd, buf, len) recv(fd, buf, len, 0)
50 #define socketWrite(fd, buf, len) send(fd, buf, len, 0)
51 #define socketClose(fd) closesocket(fd)
53 #define socketRead(fd, buf, len) read(fd, buf, len)
54 #define socketWrite(fd, buf, len) write(fd, buf, len)
55 #define socketClose(fd) close(fd)
58 static pthread_mutex_t ip_mutex = PTHREAD_MUTEX_INITIALIZER;
61 * Read a nbytes from the network.
62 * It is possible that the total bytes require in several
66 int32_t read_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
73 return (tls_bsock_readn(bsock, ptr, nbytes));
80 nread = socketRead(bsock->m_fd, ptr, nleft);
81 if (bsock->is_timed_out() || bsock->is_terminated()) {
88 if (errno == EAGAIN) {
89 bmicrosleep(0, 200000); /* try again in 200ms */
94 return nread; /* error, or EOF */
99 return nbytes - nleft; /* return >= 0 */
103 * Write nbytes to the network.
104 * It may require several writes.
107 int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
109 int32_t nleft, nwritten;
111 if (bsock->is_spooling()) {
112 nwritten = fwrite(ptr, 1, nbytes, bsock->m_spool_fd);
113 if (nwritten != nbytes) {
115 bsock->b_errno = errno;
116 Qmsg1(bsock->jcr(), M_FATAL, 0, _("Attr spool write error. ERR=%s\n"),
118 Dmsg2(400, "nwritten=%d nbytes=%d.\n", nwritten, nbytes);
119 errno = bsock->b_errno;
128 return (tls_bsock_writen(bsock, ptr, nbytes));
130 #endif /* HAVE_TLS */
136 nwritten = socketWrite(bsock->m_fd, ptr, nleft);
137 if (bsock->is_timed_out() || bsock->is_terminated()) {
140 } while (nwritten == -1 && errno == EINTR);
142 * If connection is non-blocking, we will get EAGAIN, so
143 * use select() to keep from consuming all the CPU
146 if (nwritten == -1 && errno == EAGAIN) {
151 FD_SET((unsigned)bsock->m_fd, &fdset);
154 select(bsock->m_fd + 1, NULL, &fdset, NULL, &tv);
158 return nwritten; /* error */
163 return nbytes - nleft;
167 * Receive a message from the other end. Each message consists of
168 * two packets. The first is a header that contains the size
169 * of the data that follows in the second packet.
170 * Returns number of bytes read (may return zero)
171 * Returns -1 on signal (BNET_SIGNAL)
172 * Returns -2 on hard end of file (BNET_HARDEOF)
173 * Returns -3 on error (BNET_ERROR)
175 * Unfortunately, it is a bit complicated because we have these
178 * 2. Signal including end of data stream
179 * 3. Hard end of file
181 * Using is_bnet_stop() and is_bnet_error() you can figure this all out.
183 int32_t bnet_recv(BSOCK * bsock)
185 return bsock->recv();
190 * Return 1 if there are errors on this bsock or it is closed,
191 * i.e. stop communicating on this line.
193 bool is_bnet_stop(BSOCK * bsock)
195 return bsock->errors || bsock->is_terminated();
199 * Return number of errors on socket
201 int is_bnet_error(BSOCK * bsock)
203 errno = bsock->b_errno;
204 return bsock->errors;
208 * Call here after error during closing to suppress error
209 * messages which are due to the other end shutting down too.
211 void bnet_suppress_error_messages(BSOCK * bsock, bool flag)
213 bsock->m_suppress_error_msgs = flag;
217 * Send a message over the network. The send consists of
218 * two network packets. The first is sends a 32 bit integer containing
219 * the length of the data packet which follows.
221 * Returns: false on failure
224 bool bnet_send(BSOCK *bsock)
226 return bsock->send();
231 * Establish a TLS connection -- server side
232 * Returns: true on success
236 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
239 JCR *jcr = bsock->jcr();
241 tls = new_tls_connection(ctx, bsock->m_fd);
243 Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
249 /* Initiate TLS Negotiation */
250 if (!tls_bsock_accept(bsock)) {
251 Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS Negotiation failed.\n"));
256 if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
257 Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
258 " Peer certificate did not match a required commonName\n"),
263 Dmsg0(50, "TLS server negotiation established.\n");
267 free_tls_connection(tls);
273 * Establish a TLS connection -- client side
274 * Returns: true on success
277 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
280 JCR *jcr = bsock->jcr();
282 tls = new_tls_connection(ctx, bsock->m_fd);
284 Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
290 /* Initiate TLS Negotiation */
291 if (!tls_bsock_connect(bsock)) {
295 /* If there's an Allowed CN verify list, use that to validate the remote
296 * certificate's CN. Otherwise, we use standard host/CN matching. */
298 if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
299 Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
300 " Peer certificate did not match a required commonName\n"),
305 if (!tls_postconnect_verify_host(jcr, tls, bsock->host())) {
306 Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host name \"%s\" did not match presented certificate\n"),
311 Dmsg0(50, "TLS client negotiation established.\n");
315 free_tls_connection(tls);
321 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
323 Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n"));
327 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
329 Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n"));
333 #endif /* HAVE_TLS */
336 * Wait for a specified time for data to appear on
337 * the BSOCK connection.
339 * Returns: 1 if data available
343 int bnet_wait_data(BSOCK * bsock, int sec)
345 return bsock->wait_data(sec);
349 * As above, but returns on interrupt
351 int bnet_wait_data_intr(BSOCK * bsock, int sec)
353 return bsock->wait_data_intr(sec);
356 #ifndef NETDB_INTERNAL
357 #define NETDB_INTERNAL -1 /* See errno. */
359 #ifndef NETDB_SUCCESS
360 #define NETDB_SUCCESS 0 /* No problem. */
362 #ifndef HOST_NOT_FOUND
363 #define HOST_NOT_FOUND 1 /* Authoritative Answer Host not found. */
366 #define TRY_AGAIN 2 /* Non-Authoritative Host not found, or SERVERFAIL. */
369 #define NO_RECOVERY 3 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
372 #define NO_DATA 4 /* Valid name, no data record of requested type. */
376 * Get human readable error for gethostbyname()
378 static const char *gethost_strerror()
384 msg = be.bstrerror();
387 msg = _("No problem.");
390 msg = _("Authoritative answer for host not found.");
393 msg = _("Non-authoritative for host not found, or ServerFail.");
396 msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
399 msg = _("Valid name, no data record of resquested type.");
402 msg = _("Unknown error.");
410 static IPADDR *add_any(int family)
412 IPADDR *addr = New(IPADDR(family));
413 addr->set_type(IPADDR::R_MULTIPLE);
414 addr->set_addr_any();
418 static const char *resolv_host(int family, const char *host, dlist * addr_list)
423 P(ip_mutex); /* gethostbyname() is not thread safe */
424 #ifdef HAVE_GETHOSTBYNAME2
425 if ((hp = gethostbyname2(host, family)) == NULL) {
427 if ((hp = gethostbyname(host)) == NULL) {
429 /* may be the strerror give not the right result -:( */
430 errmsg = gethost_strerror();
435 for (p = hp->h_addr_list; *p != 0; p++) {
436 IPADDR *addr = New(IPADDR(hp->h_addrtype));
437 addr->set_type(IPADDR::R_MULTIPLE);
438 if (addr->get_family() == AF_INET) {
439 addr->set_addr4((struct in_addr*)*p);
443 addr->set_addr6((struct in6_addr*)*p);
446 addr_list->append(addr);
454 * i host = 0 mean INADDR_ANY only ipv4
456 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
458 struct in_addr inaddr;
462 struct in6_addr inaddr6;
465 dlist *addr_list = New(dlist(addr, &addr->link));
466 if (!host || host[0] == '\0') {
468 addr_list->append(add_any(family));
470 addr_list->append(add_any(AF_INET));
472 addr_list->append(add_any(AF_INET6));
475 } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
476 addr = New(IPADDR(AF_INET));
477 addr->set_type(IPADDR::R_MULTIPLE);
478 addr->set_addr4(&inaddr);
479 addr_list->append(addr);
482 if (inet_pton(AF_INET6, host, &inaddr6) > 1) {
483 addr = New(IPADDR(AF_INET6));
484 addr->set_type(IPADDR::R_MULTIPLE);
485 addr->set_addr6(&inaddr6);
486 addr_list->append(addr);
491 errmsg = resolv_host(family, host, addr_list);
494 free_addresses(addr_list);
499 /* We try to resolv host for ipv6 and ipv4, the connection procedure
500 * will try to reach the host for each protocols. We report only "Host
501 * not found" ipv4 message (no need to have ipv6 and ipv4 messages).
503 resolv_host(AF_INET6, host, addr_list);
505 errmsg = resolv_host(AF_INET, host, addr_list);
507 if (addr_list->size() == 0) {
509 free_addresses(addr_list);
518 * This is the "old" way of opening a connection. The preferred way is
519 * now to do what this subroutine does, but inline. That allows the
520 * connect() call to return error status, ...
522 BSOCK *bnet_connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
524 const char *name, char *host, char *service, int port,
527 BSOCK *bsock = new_bsock();
528 if (!bsock->connect(jcr, retry_interval, max_retry_time, heart_beat,
529 name, host, service, port, verbose)) {
539 * Return the string for the error that occurred
540 * on the socket. Only the first error is retained.
542 const char *bnet_strerror(BSOCK * bsock)
544 return bsock->bstrerror();
548 * Format and send a message
549 * Returns: false on error
552 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
557 if (bs->errors || bs->is_terminated()) {
560 /* This probably won't work, but we vsnprintf, then if we
561 * get a negative length or a length greater than our buffer
562 * (depending on which library is used), the printf was truncated, so
563 * get a bigger buffer and try again.
566 maxlen = sizeof_pool_memory(bs->msg) - 1;
567 va_start(arg_ptr, fmt);
568 bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
570 if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
573 bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
578 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen)
580 return bs->get_peer(buf, buflen);
584 * Set the network buffer size, suggested size is in size.
585 * Actual size obtained is returned in bs->msglen
587 * Returns: 0 on failure
590 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
592 return bs->set_buffer_size(size, rw);
596 * Set socket non-blocking
597 * Returns previous socket flag
599 int bnet_set_nonblocking(BSOCK *bsock)
601 return bsock->set_nonblocking();
605 * Set socket blocking
606 * Returns previous socket flags
608 int bnet_set_blocking(BSOCK *bsock)
610 return bsock->set_blocking();
614 * Restores socket flags
616 void bnet_restore_blocking (BSOCK *bsock, int flags)
618 bsock->restore_blocking(flags);
623 * Send a network "signal" to the other end
624 * This consists of sending a negative packet length
626 * Returns: false on failure
629 bool bnet_sig(BSOCK * bs, int signal)
631 return bs->signal(signal);
635 * Convert a network "signal" code into
636 * human readable ASCII.
638 const char *bnet_sig_to_ascii(BSOCK * bs)
641 switch (bs->msglen) {
643 return "BNET_EOD"; /* end of data stream */
645 return "BNET_EOD_POLL";
647 return "BNET_STATUS";
649 return "BNET_TERMINATE"; /* terminate connection */
653 return "BNET_HEARTBEAT";
654 case BNET_HB_RESPONSE:
655 return "BNET_HB_RESPONSE";
657 return "BNET_PROMPT";
659 sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
664 /* Initialize internal socket structure.
665 * This probably should be done in net_open
667 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
668 struct sockaddr *client_addr)
670 Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
671 BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
672 memset(bsock, 0, sizeof(BSOCK));
673 bsock->m_fd = sockfd;
676 bsock->m_blocking = 1;
677 bsock->msg = get_pool_memory(PM_MESSAGE);
678 bsock->errmsg = get_pool_memory(PM_MESSAGE);
679 bsock->set_who(bstrdup(who));
680 bsock->set_host(bstrdup(host));
681 bsock->set_port(port);
682 memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
683 memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
685 * ****FIXME**** reduce this to a few hours once
686 * heartbeats are implemented
688 bsock->timeout = 60 * 60 * 6 * 24; /* 6 days timeout */
693 BSOCK *dup_bsock(BSOCK *osock)
695 BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
696 memcpy(bsock, osock, sizeof(BSOCK));
697 bsock->msg = get_pool_memory(PM_MESSAGE);
698 bsock->errmsg = get_pool_memory(PM_MESSAGE);
700 bsock->set_who(bstrdup(osock->who()));
703 bsock->set_host(bstrdup(osock->host()));
709 /* Close the network connection */
710 void bnet_close(BSOCK * bsock)
715 void term_bsock(BSOCK * bsock)