← Back to branch summary

~ubuntu-branches/ubuntu/vivid/sslh/vivid-proposed

« back to all changes in this revision

Viewing changes to sslh-fork.c

  • Committer: Package Import Robot
  • Author(s): Guillaume Delacour
  • Date: 2014-08-07 00:06:06 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20140807000606-y1tg7j8i5t7d4drr
Tags: 1.16-1
http://bugs.debian.org/740560
* New upstream release: fix some startup problem when interfaces are not
  ready at boot time (IP_FREEBIND support when available) and can use libcap
  for transparent mode
* Enable libcap and libwrap support at build time
* Enable dpkg-buildflags: Drop hardening-wrapper Build-Depends and use
  DEB_BUILD_HARDENING instead of DEB_BUILD_MAINT_OPTIONS
* Remove old .gitignore as upstream has one too
* debian/sslh.tmpfile: Create /run/sslh for systemd as root because sslh
  write its pid before dropping privileges (Closes: #740560)
* debian/patches/disable_ip_freebind_test.diff: Remove "Can't bind address"
  upstream test because IP_FREEBIND is now enabled upstream
* debian/docs: upstream README is now README.md
* debian/rules:
  + use DESTDIR in addition of PREFIX as upstream change Makefile
* Refresh debian/patches/disable_valgrind_launch.diff due to upstream
  changes
* Stop service in case of purge (to be able to remove the user too)
* Use DEB_BUILD_OPTIONS to speed the build
* debian/patches/fixed_version.diff: Fix the version of binaries based on
  debian/changelog (instead of relying on git)
* Update Description as sslh is not only a ssl/ssh multiplexer but a
  protocol multiplexer

Show diffs side-by-side

added added

removed removed

Lines of Context:
sslh-fork.c
69
69
{
70
70
   fd_set fds;
71
71
   struct timeval tv;
72
 
   struct addrinfo *saddr;
73
 
   int res;
 
72
   int res = PROBE_AGAIN;
74
73
   int out_socket;
75
74
   struct connection cnx;
76
 
   struct proto *prot;
77
75
 
78
76
   init_cnx(&cnx);
 
77
   cnx.q[0].fd = in_socket;
79
78
 
80
79
   FD_ZERO(&fds);
81
80
   FD_SET(in_socket, &fds);
82
81
   memset(&tv, 0, sizeof(tv));
83
82
   tv.tv_sec = probing_timeout;
84
 
   res = select(in_socket + 1, &fds, NULL, NULL, &tv);
85
 
   if (res == -1)
86
 
      perror("select");
87
 
 
88
 
   cnx.q[0].fd = in_socket;
89
 
 
90
 
   if (FD_ISSET(in_socket, &fds)) {
91
 
       /* Received data: figure out what protocol it is */
92
 
       prot = probe_client_protocol(&cnx);
93
 
   } else {
94
 
       /* Timed out: it's necessarily SSH */
95
 
       prot = timeout_protocol();
 
83
 
 
84
   while (res == PROBE_AGAIN) {
 
85
       /* POSIX does not guarantee that tv will be updated, but the client can
 
86
        * only postpone the inevitable for so long */
 
87
       res = select(in_socket + 1, &fds, NULL, NULL, &tv);
 
88
       if (res == -1)
 
89
           perror("select");
 
90
 
 
91
       if (FD_ISSET(in_socket, &fds)) {
 
92
           /* Received data: figure out what protocol it is */
 
93
           res = probe_client_protocol(&cnx);
 
94
       } else {
 
95
           /* Timed out: it's necessarily SSH */
 
96
           cnx.proto = timeout_protocol();
 
97
           break;
 
98
       }
96
99
   }
97
100
 
98
 
   saddr = prot->saddr;
99
 
   if (prot->service && 
100
 
       check_access_rights(in_socket, prot->service)) {
 
101
   if (cnx.proto->service &&
 
102
       check_access_rights(in_socket, cnx.proto->service)) {
101
103
       exit(0);
102
104
   }
103
105
 
104
106
   /* Connect the target socket */
105
 
   out_socket = connect_addr(saddr, in_socket, prot->description);
 
107
   out_socket = connect_addr(&cnx, in_socket);
106
108
   CHECK_RES_DIE(out_socket, "connect");
107
109
 
108
110
   cnx.q[1].fd = out_socket;
109
111
 
110
112
   log_connection(&cnx);
111
113
 
112
 
   flush_defered(&cnx.q[1]);
 
114
   flush_deferred(&cnx.q[1]);
113
115
 
114
116
   shovel(&cnx);
115
117
 
155
157
 
156
158
                if (!fork())
157
159
                {
158
 
                    close(listen_sockets[i]);
 
160
                    for (i = 0; i < num_addr_listen; ++i)
 
161
                        close(listen_sockets[i]);
159
162
                    start_shoveler(in_socket);
160
163
                    exit(0);
161
164
                }