← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/samba/oneiric-security

« back to all changes in this revision

Viewing changes to .pc/security-CVE-2011-0719.patch/nsswitch/libwbclient/wbc_async.c

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2011-03-10 10:03:01 UTC
  • mfrom: (0.39.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110310100301-jfjg41wv0iq05zj4
Tags: 2:3.5.8~dfsg-1ubuntu1
https://launchpad.net/bugs/639768
* Merge from debian unstable.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access. 
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/mksmbpasswd.awk:
    - Do not add user with UID less than 1000 to smbpasswd
  + debian/control:
    - Make libwbclient0 replace/conflict with hardy's likewise-open.
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
    - Add cuups breaks to push the package to aslo upgrade cups (LP: #639768)
  + debian/rules:
    - enable "native" PIE hardening.
    - Add BIND_NOW to maximize benefit of RELRO hardening.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
    - Don't ship the /etc/network/if-up.d file.
  + debian/samba.postinst: 
    - Fixed bashism.
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/samba.logrotate: Make it upstart compatible
  + debian/samba-common.dhcp: Fix typo to get a proper parsing in
    /etc/samba/dhcp.
  + Dropped:
    - debian/patches/fix-windows7-print-connection.patch: Merged upstream.
    - debian/patches/security-CVE-2011-0719.patch: Merged upstream. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/security-CVE-2011-0719.patch/nsswitch/libwbclient/wbc_async.c
1
 
/*
2
 
   Unix SMB/CIFS implementation.
3
 
   Infrastructure for async winbind requests
4
 
   Copyright (C) Volker Lendecke 2008
5
 
 
6
 
     ** NOTE! The following LGPL license applies to the wbclient
7
 
     ** library. This does NOT imply that all of Samba is released
8
 
     ** under the LGPL
9
 
 
10
 
   This library is free software; you can redistribute it and/or
11
 
   modify it under the terms of the GNU Lesser General Public
12
 
   License as published by the Free Software Foundation; either
13
 
   version 3 of the License, or (at your option) any later version.
14
 
 
15
 
   This library is distributed in the hope that it will be useful,
16
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 
   Library General Public License for more details.
19
 
 
20
 
   You should have received a copy of the GNU Lesser General Public License
21
 
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
 
*/
23
 
 
24
 
#include "replace.h"
25
 
#include "system/filesys.h"
26
 
#include "system/network.h"
27
 
#include <talloc.h>
28
 
#include <tevent.h>
29
 
#include "lib/async_req/async_sock.h"
30
 
#include "nsswitch/winbind_struct_protocol.h"
31
 
#include "nsswitch/libwbclient/wbclient.h"
32
 
#include "nsswitch/libwbclient/wbc_async.h"
33
 
 
34
 
wbcErr map_wbc_err_from_errno(int error)
35
 
{
36
 
        switch(error) {
37
 
        case EPERM:
38
 
        case EACCES:
39
 
                return WBC_ERR_AUTH_ERROR;
40
 
        case ENOMEM:
41
 
                return WBC_ERR_NO_MEMORY;
42
 
        case EIO:
43
 
        default:
44
 
                return WBC_ERR_UNKNOWN_FAILURE;
45
 
        }
46
 
}
47
 
 
48
 
bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err)
49
 
{
50
 
        enum tevent_req_state state;
51
 
        uint64_t error;
52
 
        if (!tevent_req_is_error(req, &state, &error)) {
53
 
                *pwbc_err = WBC_ERR_SUCCESS;
54
 
                return false;
55
 
        }
56
 
 
57
 
        switch (state) {
58
 
        case TEVENT_REQ_USER_ERROR:
59
 
                *pwbc_err = error;
60
 
                break;
61
 
        case TEVENT_REQ_TIMED_OUT:
62
 
                *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
63
 
                break;
64
 
        case TEVENT_REQ_NO_MEMORY:
65
 
                *pwbc_err = WBC_ERR_NO_MEMORY;
66
 
                break;
67
 
        default:
68
 
                *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
69
 
                break;
70
 
        }
71
 
        return true;
72
 
}
73
 
 
74
 
wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req)
75
 
{
76
 
        wbcErr wbc_err;
77
 
 
78
 
        if (tevent_req_is_wbcerr(req, &wbc_err)) {
79
 
                return wbc_err;
80
 
        }
81
 
 
82
 
        return WBC_ERR_SUCCESS;
83
 
}
84
 
 
85
 
struct wbc_debug_ops {
86
 
        void (*debug)(void *context, enum wbcDebugLevel level,
87
 
                      const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0);
88
 
        void *context;
89
 
};
90
 
 
91
 
struct wb_context {
92
 
        struct tevent_queue *queue;
93
 
        int fd;
94
 
        bool is_priv;
95
 
        const char *dir;
96
 
        struct wbc_debug_ops debug_ops;
97
 
};
98
 
 
99
 
static int make_nonstd_fd(int fd)
100
 
{
101
 
        int i;
102
 
        int sys_errno = 0;
103
 
        int fds[3];
104
 
        int num_fds = 0;
105
 
 
106
 
        if (fd == -1) {
107
 
                return -1;
108
 
        }
109
 
        while (fd < 3) {
110
 
                fds[num_fds++] = fd;
111
 
                fd = dup(fd);
112
 
                if (fd == -1) {
113
 
                        sys_errno = errno;
114
 
                        break;
115
 
                }
116
 
        }
117
 
        for (i=0; i<num_fds; i++) {
118
 
                close(fds[i]);
119
 
        }
120
 
        if (fd == -1) {
121
 
                errno = sys_errno;
122
 
        }
123
 
        return fd;
124
 
}
125
 
 
126
 
/****************************************************************************
127
 
 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
128
 
 else
129
 
 if SYSV use O_NDELAY
130
 
 if BSD use FNDELAY
131
 
 Set close on exec also.
132
 
****************************************************************************/
133
 
 
134
 
static int make_safe_fd(int fd)
135
 
{
136
 
        int result, flags;
137
 
        int new_fd = make_nonstd_fd(fd);
138
 
 
139
 
        if (new_fd == -1) {
140
 
                goto fail;
141
 
        }
142
 
 
143
 
        /* Socket should be nonblocking. */
144
 
 
145
 
#ifdef O_NONBLOCK
146
 
#define FLAG_TO_SET O_NONBLOCK
147
 
#else
148
 
#ifdef SYSV
149
 
#define FLAG_TO_SET O_NDELAY
150
 
#else /* BSD */
151
 
#define FLAG_TO_SET FNDELAY
152
 
#endif
153
 
#endif
154
 
 
155
 
        if ((flags = fcntl(new_fd, F_GETFL)) == -1) {
156
 
                goto fail;
157
 
        }
158
 
 
159
 
        flags |= FLAG_TO_SET;
160
 
        if (fcntl(new_fd, F_SETFL, flags) == -1) {
161
 
                goto fail;
162
 
        }
163
 
 
164
 
#undef FLAG_TO_SET
165
 
 
166
 
        /* Socket should be closed on exec() */
167
 
#ifdef FD_CLOEXEC
168
 
        result = flags = fcntl(new_fd, F_GETFD, 0);
169
 
        if (flags >= 0) {
170
 
                flags |= FD_CLOEXEC;
171
 
                result = fcntl( new_fd, F_SETFD, flags );
172
 
        }
173
 
        if (result < 0) {
174
 
                goto fail;
175
 
        }
176
 
#endif
177
 
        return new_fd;
178
 
 
179
 
 fail:
180
 
        if (new_fd != -1) {
181
 
                int sys_errno = errno;
182
 
                close(new_fd);
183
 
                errno = sys_errno;
184
 
        }
185
 
        return -1;
186
 
}
187
 
 
188
 
/* Just put a prototype to avoid moving the whole function around */
189
 
static const char *winbindd_socket_dir(void);
190
 
 
191
 
struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx, const char* dir)
192
 
{
193
 
        struct wb_context *result;
194
 
 
195
 
        result = talloc(mem_ctx, struct wb_context);
196
 
        if (result == NULL) {
197
 
                return NULL;
198
 
        }
199
 
        result->queue = tevent_queue_create(result, "wb_trans");
200
 
        if (result->queue == NULL) {
201
 
                TALLOC_FREE(result);
202
 
                return NULL;
203
 
        }
204
 
        result->fd = -1;
205
 
        result->is_priv = false;
206
 
 
207
 
        if (dir != NULL) {
208
 
                result->dir = talloc_strdup(result, dir);
209
 
        } else {
210
 
                result->dir = winbindd_socket_dir();
211
 
        }
212
 
        if (result->dir == NULL) {
213
 
                TALLOC_FREE(result);
214
 
                return NULL;
215
 
        }
216
 
        return result;
217
 
}
218
 
 
219
 
struct wb_connect_state {
220
 
        int dummy;
221
 
};
222
 
 
223
 
static void wbc_connect_connected(struct tevent_req *subreq);
224
 
 
225
 
static struct tevent_req *wb_connect_send(TALLOC_CTX *mem_ctx,
226
 
                                          struct tevent_context *ev,
227
 
                                          struct wb_context *wb_ctx,
228
 
                                          const char *dir)
229
 
{
230
 
        struct tevent_req *result, *subreq;
231
 
        struct wb_connect_state *state;
232
 
        struct sockaddr_un sunaddr;
233
 
        struct stat st;
234
 
        char *path = NULL;
235
 
        wbcErr wbc_err;
236
 
 
237
 
        result = tevent_req_create(mem_ctx, &state, struct wb_connect_state);
238
 
        if (result == NULL) {
239
 
                return NULL;
240
 
        }
241
 
 
242
 
        if (wb_ctx->fd != -1) {
243
 
                close(wb_ctx->fd);
244
 
                wb_ctx->fd = -1;
245
 
        }
246
 
 
247
 
        /* Check permissions on unix socket directory */
248
 
 
249
 
        if (lstat(dir, &st) == -1) {
250
 
                wbc_err = WBC_ERR_WINBIND_NOT_AVAILABLE;
251
 
                goto post_status;
252
 
        }
253
 
 
254
 
        if (!S_ISDIR(st.st_mode) ||
255
 
            (st.st_uid != 0 && st.st_uid != geteuid())) {
256
 
                wbc_err = WBC_ERR_WINBIND_NOT_AVAILABLE;
257
 
                goto post_status;
258
 
        }
259
 
 
260
 
        /* Connect to socket */
261
 
 
262
 
        path = talloc_asprintf(mem_ctx, "%s/%s", dir,
263
 
                               WINBINDD_SOCKET_NAME);
264
 
        if (path == NULL) {
265
 
                goto nomem;
266
 
        }
267
 
 
268
 
        sunaddr.sun_family = AF_UNIX;
269
 
        strlcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path));
270
 
        TALLOC_FREE(path);
271
 
 
272
 
        /* If socket file doesn't exist, don't bother trying to connect
273
 
           with retry.  This is an attempt to make the system usable when
274
 
           the winbindd daemon is not running. */
275
 
 
276
 
        if ((lstat(sunaddr.sun_path, &st) == -1)
277
 
            || !S_ISSOCK(st.st_mode)
278
 
            || (st.st_uid != 0 && st.st_uid != geteuid())) {
279
 
                wbc_err = WBC_ERR_WINBIND_NOT_AVAILABLE;
280
 
                goto post_status;
281
 
        }
282
 
 
283
 
        wb_ctx->fd = make_safe_fd(socket(AF_UNIX, SOCK_STREAM, 0));
284
 
        if (wb_ctx->fd == -1) {
285
 
                wbc_err = map_wbc_err_from_errno(errno);
286
 
                goto post_status;
287
 
        }
288
 
 
289
 
        subreq = async_connect_send(mem_ctx, ev, wb_ctx->fd,
290
 
                                    (struct sockaddr *)(void *)&sunaddr,
291
 
                                    sizeof(sunaddr));
292
 
        if (subreq == NULL) {
293
 
                goto nomem;
294
 
        }
295
 
        tevent_req_set_callback(subreq, wbc_connect_connected, result);
296
 
        return result;
297
 
 
298
 
 post_status:
299
 
        tevent_req_error(result, wbc_err);
300
 
        return tevent_req_post(result, ev);
301
 
 nomem:
302
 
        TALLOC_FREE(result);
303
 
        return NULL;
304
 
}
305
 
 
306
 
static void wbc_connect_connected(struct tevent_req *subreq)
307
 
{
308
 
        struct tevent_req *req = tevent_req_callback_data(
309
 
                subreq, struct tevent_req);
310
 
        int res, err;
311
 
 
312
 
        res = async_connect_recv(subreq, &err);
313
 
        TALLOC_FREE(subreq);
314
 
        if (res == -1) {
315
 
                tevent_req_error(req, map_wbc_err_from_errno(err));
316
 
                return;
317
 
        }
318
 
        tevent_req_done(req);
319
 
}
320
 
 
321
 
static wbcErr wb_connect_recv(struct tevent_req *req)
322
 
{
323
 
        return tevent_req_simple_recv_wbcerr(req);
324
 
}
325
 
 
326
 
static const char *winbindd_socket_dir(void)
327
 
{
328
 
#ifdef SOCKET_WRAPPER
329
 
        const char *env_dir;
330
 
 
331
 
        env_dir = getenv(WINBINDD_SOCKET_DIR_ENVVAR);
332
 
        if (env_dir) {
333
 
                return env_dir;
334
 
        }
335
 
#endif
336
 
 
337
 
        return WINBINDD_SOCKET_DIR;
338
 
}
339
 
 
340
 
struct wb_open_pipe_state {
341
 
        struct wb_context *wb_ctx;
342
 
        struct tevent_context *ev;
343
 
        bool need_priv;
344
 
        struct winbindd_request wb_req;
345
 
};
346
 
 
347
 
static void wb_open_pipe_connect_nonpriv_done(struct tevent_req *subreq);
348
 
static void wb_open_pipe_ping_done(struct tevent_req *subreq);
349
 
static void wb_open_pipe_getpriv_done(struct tevent_req *subreq);
350
 
static void wb_open_pipe_connect_priv_done(struct tevent_req *subreq);
351
 
 
352
 
static struct tevent_req *wb_open_pipe_send(TALLOC_CTX *mem_ctx,
353
 
                                            struct tevent_context *ev,
354
 
                                            struct wb_context *wb_ctx,
355
 
                                            bool need_priv)
356
 
{
357
 
        struct tevent_req *result, *subreq;
358
 
        struct wb_open_pipe_state *state;
359
 
 
360
 
        result = tevent_req_create(mem_ctx, &state, struct wb_open_pipe_state);
361
 
        if (result == NULL) {
362
 
                return NULL;
363
 
        }
364
 
        state->wb_ctx = wb_ctx;
365
 
        state->ev = ev;
366
 
        state->need_priv = need_priv;
367
 
 
368
 
        if (wb_ctx->fd != -1) {
369
 
                close(wb_ctx->fd);
370
 
                wb_ctx->fd = -1;
371
 
        }
372
 
 
373
 
        subreq = wb_connect_send(state, ev, wb_ctx, wb_ctx->dir);
374
 
        if (subreq == NULL) {
375
 
                goto fail;
376
 
        }
377
 
        tevent_req_set_callback(subreq, wb_open_pipe_connect_nonpriv_done,
378
 
                                result);
379
 
        return result;
380
 
 
381
 
 fail:
382
 
        TALLOC_FREE(result);
383
 
        return NULL;
384
 
}
385
 
 
386
 
static void wb_open_pipe_connect_nonpriv_done(struct tevent_req *subreq)
387
 
{
388
 
        struct tevent_req *req = tevent_req_callback_data(
389
 
                subreq, struct tevent_req);
390
 
        struct wb_open_pipe_state *state = tevent_req_data(
391
 
                req, struct wb_open_pipe_state);
392
 
        wbcErr wbc_err;
393
 
 
394
 
        wbc_err = wb_connect_recv(subreq);
395
 
        TALLOC_FREE(subreq);
396
 
        if (!WBC_ERROR_IS_OK(wbc_err)) {
397
 
                state->wb_ctx->is_priv = true;
398
 
                tevent_req_error(req, wbc_err);
399
 
                return;
400
 
        }
401
 
 
402
 
        ZERO_STRUCT(state->wb_req);
403
 
        state->wb_req.cmd = WINBINDD_INTERFACE_VERSION;
404
 
        state->wb_req.pid = getpid();
405
 
 
406
 
        subreq = wb_simple_trans_send(state, state->ev, NULL,
407
 
                                      state->wb_ctx->fd, &state->wb_req);
408
 
        if (tevent_req_nomem(subreq, req)) {
409
 
                return;
410
 
        }
411
 
        tevent_req_set_callback(subreq, wb_open_pipe_ping_done, req);
412
 
}
413
 
 
414
 
static void wb_open_pipe_ping_done(struct tevent_req *subreq)
415
 
{
416
 
        struct tevent_req *req = tevent_req_callback_data(
417
 
                subreq, struct tevent_req);
418
 
        struct wb_open_pipe_state *state = tevent_req_data(
419
 
                req, struct wb_open_pipe_state);
420
 
        struct winbindd_response *wb_resp;
421
 
        int ret, err;
422
 
 
423
 
        ret = wb_simple_trans_recv(subreq, state, &wb_resp, &err);
424
 
        TALLOC_FREE(subreq);
425
 
        if (ret == -1) {
426
 
                tevent_req_error(req, map_wbc_err_from_errno(err));
427
 
                return;
428
 
        }
429
 
 
430
 
        if (!state->need_priv) {
431
 
                tevent_req_done(req);
432
 
                return;
433
 
        }
434
 
 
435
 
        state->wb_req.cmd = WINBINDD_PRIV_PIPE_DIR;
436
 
        state->wb_req.pid = getpid();
437
 
 
438
 
        subreq = wb_simple_trans_send(state, state->ev, NULL,
439
 
                                      state->wb_ctx->fd, &state->wb_req);
440
 
        if (tevent_req_nomem(subreq, req)) {
441
 
                return;
442
 
        }
443
 
        tevent_req_set_callback(subreq, wb_open_pipe_getpriv_done, req);
444
 
}
445
 
 
446
 
static void wb_open_pipe_getpriv_done(struct tevent_req *subreq)
447
 
{
448
 
        struct tevent_req *req = tevent_req_callback_data(
449
 
                subreq, struct tevent_req);
450
 
        struct wb_open_pipe_state *state = tevent_req_data(
451
 
                req, struct wb_open_pipe_state);
452
 
        struct winbindd_response *wb_resp = NULL;
453
 
        int ret, err;
454
 
 
455
 
        ret = wb_simple_trans_recv(subreq, state, &wb_resp, &err);
456
 
        TALLOC_FREE(subreq);
457
 
        if (ret == -1) {
458
 
                tevent_req_error(req, map_wbc_err_from_errno(err));
459
 
                return;
460
 
        }
461
 
 
462
 
        close(state->wb_ctx->fd);
463
 
        state->wb_ctx->fd = -1;
464
 
 
465
 
        subreq = wb_connect_send(state, state->ev, state->wb_ctx,
466
 
                                  (char *)wb_resp->extra_data.data);
467
 
        TALLOC_FREE(wb_resp);
468
 
        if (tevent_req_nomem(subreq, req)) {
469
 
                return;
470
 
        }
471
 
        tevent_req_set_callback(subreq, wb_open_pipe_connect_priv_done, req);
472
 
}
473
 
 
474
 
static void wb_open_pipe_connect_priv_done(struct tevent_req *subreq)
475
 
{
476
 
        struct tevent_req *req = tevent_req_callback_data(
477
 
                subreq, struct tevent_req);
478
 
        struct wb_open_pipe_state *state = tevent_req_data(
479
 
                req, struct wb_open_pipe_state);
480
 
        wbcErr wbc_err;
481
 
 
482
 
        wbc_err = wb_connect_recv(subreq);
483
 
        TALLOC_FREE(subreq);
484
 
        if (!WBC_ERROR_IS_OK(wbc_err)) {
485
 
                tevent_req_error(req, wbc_err);
486
 
                return;
487
 
        }
488
 
        state->wb_ctx->is_priv = true;
489
 
        tevent_req_done(req);
490
 
}
491
 
 
492
 
static wbcErr wb_open_pipe_recv(struct tevent_req *req)
493
 
{
494
 
        return tevent_req_simple_recv_wbcerr(req);
495
 
}
496
 
 
497
 
struct wb_trans_state {
498
 
        struct wb_trans_state *prev, *next;
499
 
        struct wb_context *wb_ctx;
500
 
        struct tevent_context *ev;
501
 
        struct winbindd_request *wb_req;
502
 
        struct winbindd_response *wb_resp;
503
 
        bool need_priv;
504
 
};
505
 
 
506
 
static bool closed_fd(int fd)
507
 
{
508
 
        struct timeval tv;
509
 
        fd_set r_fds;
510
 
        int selret;
511
 
 
512
 
        if (fd == -1) {
513
 
                return true;
514
 
        }
515
 
 
516
 
        FD_ZERO(&r_fds);
517
 
        FD_SET(fd, &r_fds);
518
 
        ZERO_STRUCT(tv);
519
 
 
520
 
        selret = select(fd+1, &r_fds, NULL, NULL, &tv);
521
 
        if (selret == -1) {
522
 
                return true;
523
 
        }
524
 
        if (selret == 0) {
525
 
                return false;
526
 
        }
527
 
        return (FD_ISSET(fd, &r_fds));
528
 
}
529
 
 
530
 
static void wb_trans_trigger(struct tevent_req *req, void *private_data);
531
 
static void wb_trans_connect_done(struct tevent_req *subreq);
532
 
static void wb_trans_done(struct tevent_req *subreq);
533
 
static void wb_trans_retry_wait_done(struct tevent_req *subreq);
534
 
 
535
 
struct tevent_req *wb_trans_send(TALLOC_CTX *mem_ctx,
536
 
                                 struct tevent_context *ev,
537
 
                                 struct wb_context *wb_ctx, bool need_priv,
538
 
                                 struct winbindd_request *wb_req)
539
 
{
540
 
        struct tevent_req *req;
541
 
        struct wb_trans_state *state;
542
 
 
543
 
        req = tevent_req_create(mem_ctx, &state, struct wb_trans_state);
544
 
        if (req == NULL) {
545
 
                return NULL;
546
 
        }
547
 
        state->wb_ctx = wb_ctx;
548
 
        state->ev = ev;
549
 
        state->wb_req = wb_req;
550
 
        state->need_priv = need_priv;
551
 
 
552
 
        if (!tevent_queue_add(wb_ctx->queue, ev, req, wb_trans_trigger,
553
 
                              NULL)) {
554
 
                tevent_req_nomem(NULL, req);
555
 
                return tevent_req_post(req, ev);
556
 
        }
557
 
        return req;
558
 
}
559
 
 
560
 
static void wb_trans_trigger(struct tevent_req *req, void *private_data)
561
 
{
562
 
        struct wb_trans_state *state = tevent_req_data(
563
 
                req, struct wb_trans_state);
564
 
        struct tevent_req *subreq;
565
 
 
566
 
        if ((state->wb_ctx->fd != -1) && closed_fd(state->wb_ctx->fd)) {
567
 
                close(state->wb_ctx->fd);
568
 
                state->wb_ctx->fd = -1;
569
 
        }
570
 
 
571
 
        if ((state->wb_ctx->fd == -1)
572
 
            || (state->need_priv && !state->wb_ctx->is_priv)) {
573
 
                subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
574
 
                                           state->need_priv);
575
 
                if (tevent_req_nomem(subreq, req)) {
576
 
                        return;
577
 
                }
578
 
                tevent_req_set_callback(subreq, wb_trans_connect_done, req);
579
 
                return;
580
 
        }
581
 
 
582
 
        state->wb_req->pid = getpid();
583
 
 
584
 
        subreq = wb_simple_trans_send(state, state->ev, NULL,
585
 
                                      state->wb_ctx->fd, state->wb_req);
586
 
        if (tevent_req_nomem(subreq, req)) {
587
 
                return;
588
 
        }
589
 
        tevent_req_set_callback(subreq, wb_trans_done, req);
590
 
}
591
 
 
592
 
static bool wb_trans_retry(struct tevent_req *req,
593
 
                           struct wb_trans_state *state,
594
 
                           wbcErr wbc_err)
595
 
{
596
 
        struct tevent_req *subreq;
597
 
 
598
 
        if (WBC_ERROR_IS_OK(wbc_err)) {
599
 
                return false;
600
 
        }
601
 
 
602
 
        if (wbc_err == WBC_ERR_WINBIND_NOT_AVAILABLE) {
603
 
                /*
604
 
                 * Winbind not around or we can't connect to the pipe. Fail
605
 
                 * immediately.
606
 
                 */
607
 
                tevent_req_error(req, wbc_err);
608
 
                return true;
609
 
        }
610
 
 
611
 
        /*
612
 
         * The transfer as such failed, retry after one second
613
 
         */
614
 
 
615
 
        if (state->wb_ctx->fd != -1) {
616
 
                close(state->wb_ctx->fd);
617
 
                state->wb_ctx->fd = -1;
618
 
        }
619
 
 
620
 
        subreq = tevent_wakeup_send(state, state->ev,
621
 
                                    tevent_timeval_current_ofs(1, 0));
622
 
        if (tevent_req_nomem(subreq, req)) {
623
 
                return true;
624
 
        }
625
 
        tevent_req_set_callback(subreq, wb_trans_retry_wait_done, req);
626
 
        return true;
627
 
}
628
 
 
629
 
static void wb_trans_retry_wait_done(struct tevent_req *subreq)
630
 
{
631
 
        struct tevent_req *req = tevent_req_callback_data(
632
 
                subreq, struct tevent_req);
633
 
        struct wb_trans_state *state = tevent_req_data(
634
 
                req, struct wb_trans_state);
635
 
        bool ret;
636
 
 
637
 
        ret = tevent_wakeup_recv(subreq);
638
 
        TALLOC_FREE(subreq);
639
 
        if (!ret) {
640
 
                tevent_req_error(req, WBC_ERR_UNKNOWN_FAILURE);
641
 
                return;
642
 
        }
643
 
 
644
 
        subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
645
 
                                   state->need_priv);
646
 
        if (tevent_req_nomem(subreq, req)) {
647
 
                return;
648
 
        }
649
 
        tevent_req_set_callback(subreq, wb_trans_connect_done, req);
650
 
}
651
 
 
652
 
static void wb_trans_connect_done(struct tevent_req *subreq)
653
 
{
654
 
        struct tevent_req *req = tevent_req_callback_data(
655
 
                subreq, struct tevent_req);
656
 
        struct wb_trans_state *state = tevent_req_data(
657
 
                req, struct wb_trans_state);
658
 
        wbcErr wbc_err;
659
 
 
660
 
        wbc_err = wb_open_pipe_recv(subreq);
661
 
        TALLOC_FREE(subreq);
662
 
 
663
 
        if (wb_trans_retry(req, state, wbc_err)) {
664
 
                return;
665
 
        }
666
 
 
667
 
        subreq = wb_simple_trans_send(state, state->ev, NULL,
668
 
                                      state->wb_ctx->fd, state->wb_req);
669
 
        if (tevent_req_nomem(subreq, req)) {
670
 
                return;
671
 
        }
672
 
        tevent_req_set_callback(subreq, wb_trans_done, req);
673
 
}
674
 
 
675
 
static void wb_trans_done(struct tevent_req *subreq)
676
 
{
677
 
        struct tevent_req *req = tevent_req_callback_data(
678
 
                subreq, struct tevent_req);
679
 
        struct wb_trans_state *state = tevent_req_data(
680
 
                req, struct wb_trans_state);
681
 
        int ret, err;
682
 
 
683
 
        ret = wb_simple_trans_recv(subreq, state, &state->wb_resp, &err);
684
 
        TALLOC_FREE(subreq);
685
 
        if ((ret == -1)
686
 
            && wb_trans_retry(req, state, map_wbc_err_from_errno(err))) {
687
 
                return;
688
 
        }
689
 
 
690
 
        tevent_req_done(req);
691
 
}
692
 
 
693
 
wbcErr wb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
694
 
                     struct winbindd_response **presponse)
695
 
{
696
 
        struct wb_trans_state *state = tevent_req_data(
697
 
                req, struct wb_trans_state);
698
 
        wbcErr wbc_err;
699
 
 
700
 
        if (tevent_req_is_wbcerr(req, &wbc_err)) {
701
 
                return wbc_err;
702
 
        }
703
 
 
704
 
        *presponse = talloc_move(mem_ctx, &state->wb_resp);
705
 
        return WBC_ERR_SUCCESS;
706
 
}
707
 
 
708
 
/********************************************************************
709
 
 * Debug wrapper functions, modeled (with lot's of code copied as is)
710
 
 * after the tevent debug wrapper functions
711
 
 ********************************************************************/
712
 
 
713
 
/*
714
 
  this allows the user to choose their own debug function
715
 
*/
716
 
int wbcSetDebug(struct wb_context *wb_ctx,
717
 
                void (*debug)(void *context,
718
 
                              enum wbcDebugLevel level,
719
 
                              const char *fmt,
720
 
                              va_list ap) PRINTF_ATTRIBUTE(3,0),
721
 
                void *context)
722
 
{
723
 
        wb_ctx->debug_ops.debug = debug;
724
 
        wb_ctx->debug_ops.context = context;
725
 
        return 0;
726
 
}
727
 
 
728
 
/*
729
 
  debug function for wbcSetDebugStderr
730
 
*/
731
 
static void wbcDebugStderr(void *private_data,
732
 
                           enum wbcDebugLevel level,
733
 
                           const char *fmt,
734
 
                           va_list ap) PRINTF_ATTRIBUTE(3,0);
735
 
static void wbcDebugStderr(void *private_data,
736
 
                           enum wbcDebugLevel level,
737
 
                           const char *fmt, va_list ap)
738
 
{
739
 
        if (level <= WBC_DEBUG_WARNING) {
740
 
                vfprintf(stderr, fmt, ap);
741
 
        }
742
 
}
743
 
 
744
 
/*
745
 
  convenience function to setup debug messages on stderr
746
 
  messages of level WBC_DEBUG_WARNING and higher are printed
747
 
*/
748
 
int wbcSetDebugStderr(struct wb_context *wb_ctx)
749
 
{
750
 
        return wbcSetDebug(wb_ctx, wbcDebugStderr, wb_ctx);
751
 
}
752
 
 
753
 
/*
754
 
 * log a message
755
 
 *
756
 
 * The default debug action is to ignore debugging messages.
757
 
 * This is the most appropriate action for a library.
758
 
 * Applications using the library must decide where to
759
 
 * redirect debugging messages
760
 
*/
761
 
void wbcDebug(struct wb_context *wb_ctx, enum wbcDebugLevel level,
762
 
              const char *fmt, ...)
763
 
{
764
 
        va_list ap;
765
 
        if (!wb_ctx) {
766
 
                return;
767
 
        }
768
 
        if (wb_ctx->debug_ops.debug == NULL) {
769
 
                return;
770
 
        }
771
 
        va_start(ap, fmt);
772
 
        wb_ctx->debug_ops.debug(wb_ctx->debug_ops.context, level, fmt, ap);
773
 
        va_end(ap);
774
 
}