← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to nsswitch/libwbclient/wb_reqtrans.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + 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/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + 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.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - 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/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
nsswitch/libwbclient/wb_reqtrans.c
1
 
/*
2
 
   Unix SMB/CIFS implementation.
3
 
 
4
 
   Async transfer of winbindd_request and _response structs
5
 
 
6
 
   Copyright (C) Volker Lendecke 2008
7
 
 
8
 
     ** NOTE! The following LGPL license applies to the wbclient
9
 
     ** library. This does NOT imply that all of Samba is released
10
 
     ** under the LGPL
11
 
 
12
 
   This library is free software; you can redistribute it and/or
13
 
   modify it under the terms of the GNU Lesser General Public
14
 
   License as published by the Free Software Foundation; either
15
 
   version 3 of the License, or (at your option) any later version.
16
 
 
17
 
   This library is distributed in the hope that it will be useful,
18
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
19
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
 
   Library General Public License for more details.
21
 
 
22
 
   You should have received a copy of the GNU Lesser General Public License
23
 
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
24
 
*/
25
 
 
26
 
#include "replace.h"
27
 
#include "system/filesys.h"
28
 
#include "system/network.h"
29
 
#include <talloc.h>
30
 
#include <tevent.h>
31
 
#include "lib/async_req/async_sock.h"
32
 
#include "lib/util/tevent_unix.h"
33
 
#include "nsswitch/winbind_struct_protocol.h"
34
 
#include "nsswitch/libwbclient/wbclient.h"
35
 
#include "nsswitch/libwbclient/wbc_async.h"
36
 
 
37
 
/* can't use DEBUG here... */
38
 
#define DEBUG(a,b)
39
 
 
40
 
struct req_read_state {
41
 
        struct winbindd_request *wb_req;
42
 
        size_t max_extra_data;
43
 
        ssize_t ret;
44
 
};
45
 
 
46
 
static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data);
47
 
static void wb_req_read_done(struct tevent_req *subreq);
48
 
 
49
 
struct tevent_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
50
 
                                    struct tevent_context *ev,
51
 
                                    int fd, size_t max_extra_data)
52
 
{
53
 
        struct tevent_req *req, *subreq;
54
 
        struct req_read_state *state;
55
 
 
56
 
        req = tevent_req_create(mem_ctx, &state, struct req_read_state);
57
 
        if (req == NULL) {
58
 
                return NULL;
59
 
        }
60
 
        state->max_extra_data = max_extra_data;
61
 
 
62
 
        subreq = read_packet_send(state, ev, fd, 4, wb_req_more, state);
63
 
        if (tevent_req_nomem(subreq, req)) {
64
 
                return tevent_req_post(req, ev);
65
 
        }
66
 
        tevent_req_set_callback(subreq, wb_req_read_done, req);
67
 
        return req;
68
 
}
69
 
 
70
 
static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data)
71
 
{
72
 
        struct req_read_state *state = talloc_get_type_abort(
73
 
                private_data, struct req_read_state);
74
 
        struct winbindd_request *req = (struct winbindd_request *)buf;
75
 
 
76
 
        if (buflen == 4) {
77
 
                if (req->length != sizeof(struct winbindd_request)) {
78
 
                        DEBUG(0, ("wb_req_read_len: Invalid request size "
79
 
                                  "received: %d (expected %d)\n",
80
 
                                  (int)req->length,
81
 
                                  (int)sizeof(struct winbindd_request)));
82
 
                        return -1;
83
 
                }
84
 
                return sizeof(struct winbindd_request) - 4;
85
 
        }
86
 
 
87
 
        if (buflen > sizeof(struct winbindd_request)) {
88
 
                /* We've been here, we're done */
89
 
                return 0;
90
 
        }
91
 
 
92
 
        if ((state->max_extra_data != 0)
93
 
            && (req->extra_len > state->max_extra_data)) {
94
 
                DEBUG(3, ("Got request with %d bytes extra data on "
95
 
                          "unprivileged socket\n", (int)req->extra_len));
96
 
                return -1;
97
 
        }
98
 
 
99
 
        return req->extra_len;
100
 
}
101
 
 
102
 
static void wb_req_read_done(struct tevent_req *subreq)
103
 
{
104
 
        struct tevent_req *req = tevent_req_callback_data(
105
 
                subreq, struct tevent_req);
106
 
        struct req_read_state *state = tevent_req_data(
107
 
                req, struct req_read_state);
108
 
        int err;
109
 
        uint8_t *buf;
110
 
 
111
 
        state->ret = read_packet_recv(subreq, state, &buf, &err);
112
 
        TALLOC_FREE(subreq);
113
 
        if (state->ret == -1) {
114
 
                tevent_req_error(req, err);
115
 
                return;
116
 
        }
117
 
 
118
 
        state->wb_req = (struct winbindd_request *)buf;
119
 
 
120
 
        if (state->wb_req->extra_len != 0) {
121
 
                state->wb_req->extra_data.data =
122
 
                        (char *)buf + sizeof(struct winbindd_request);
123
 
        } else {
124
 
                state->wb_req->extra_data.data = NULL;
125
 
        }
126
 
        tevent_req_done(req);
127
 
}
128
 
 
129
 
ssize_t wb_req_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
130
 
                         struct winbindd_request **preq, int *err)
131
 
{
132
 
        struct req_read_state *state = tevent_req_data(
133
 
                req, struct req_read_state);
134
 
 
135
 
        if (tevent_req_is_unix_error(req, err)) {
136
 
                return -1;
137
 
        }
138
 
        *preq = talloc_move(mem_ctx, &state->wb_req);
139
 
        return state->ret;
140
 
}
141
 
 
142
 
struct req_write_state {
143
 
        struct iovec iov[2];
144
 
        ssize_t ret;
145
 
};
146
 
 
147
 
static void wb_req_write_done(struct tevent_req *subreq);
148
 
 
149
 
struct tevent_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
150
 
                                     struct tevent_context *ev,
151
 
                                     struct tevent_queue *queue, int fd,
152
 
                                     struct winbindd_request *wb_req)
153
 
{
154
 
        struct tevent_req *req, *subreq;
155
 
        struct req_write_state *state;
156
 
        int count = 1;
157
 
 
158
 
        req = tevent_req_create(mem_ctx, &state, struct req_write_state);
159
 
        if (req == NULL) {
160
 
                return NULL;
161
 
        }
162
 
 
163
 
        state->iov[0].iov_base = (void *)wb_req;
164
 
        state->iov[0].iov_len = sizeof(struct winbindd_request);
165
 
 
166
 
        if (wb_req->extra_len != 0) {
167
 
                state->iov[1].iov_base = (void *)wb_req->extra_data.data;
168
 
                state->iov[1].iov_len = wb_req->extra_len;
169
 
                count = 2;
170
 
        }
171
 
 
172
 
        subreq = writev_send(state, ev, queue, fd, true, state->iov, count);
173
 
        if (tevent_req_nomem(subreq, req)) {
174
 
                return tevent_req_post(req, ev);
175
 
        }
176
 
        tevent_req_set_callback(subreq, wb_req_write_done, req);
177
 
        return req;
178
 
}
179
 
 
180
 
static void wb_req_write_done(struct tevent_req *subreq)
181
 
{
182
 
        struct tevent_req *req = tevent_req_callback_data(
183
 
                subreq, struct tevent_req);
184
 
        struct req_write_state *state = tevent_req_data(
185
 
                req, struct req_write_state);
186
 
        int err;
187
 
 
188
 
        state->ret = writev_recv(subreq, &err);
189
 
        TALLOC_FREE(subreq);
190
 
        if (state->ret < 0) {
191
 
                tevent_req_error(req, err);
192
 
                return;
193
 
        }
194
 
        tevent_req_done(req);
195
 
}
196
 
 
197
 
ssize_t wb_req_write_recv(struct tevent_req *req, int *err)
198
 
{
199
 
        struct req_write_state *state = tevent_req_data(
200
 
                req, struct req_write_state);
201
 
 
202
 
        if (tevent_req_is_unix_error(req, err)) {
203
 
                return -1;
204
 
        }
205
 
        return state->ret;
206
 
}
207
 
 
208
 
struct resp_read_state {
209
 
        struct winbindd_response *wb_resp;
210
 
        ssize_t ret;
211
 
};
212
 
 
213
 
static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data);
214
 
static void wb_resp_read_done(struct tevent_req *subreq);
215
 
 
216
 
struct tevent_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
217
 
                                     struct tevent_context *ev, int fd)
218
 
{
219
 
        struct tevent_req *req, *subreq;
220
 
        struct resp_read_state *state;
221
 
 
222
 
        req = tevent_req_create(mem_ctx, &state, struct resp_read_state);
223
 
        if (req == NULL) {
224
 
                return NULL;
225
 
        }
226
 
 
227
 
        subreq = read_packet_send(state, ev, fd, 4, wb_resp_more, state);
228
 
        if (tevent_req_nomem(subreq, req)) {
229
 
                return tevent_req_post(req, ev);
230
 
        }
231
 
        tevent_req_set_callback(subreq, wb_resp_read_done, req);
232
 
        return req;
233
 
}
234
 
 
235
 
static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data)
236
 
{
237
 
        struct winbindd_response *resp = (struct winbindd_response *)buf;
238
 
 
239
 
        if (buflen == 4) {
240
 
                if (resp->length < sizeof(struct winbindd_response)) {
241
 
                        DEBUG(0, ("wb_resp_read_len: Invalid response size "
242
 
                                  "received: %d (expected at least%d)\n",
243
 
                                  (int)resp->length,
244
 
                                  (int)sizeof(struct winbindd_response)));
245
 
                        return -1;
246
 
                }
247
 
        }
248
 
        return resp->length - buflen;
249
 
}
250
 
 
251
 
static void wb_resp_read_done(struct tevent_req *subreq)
252
 
{
253
 
        struct tevent_req *req = tevent_req_callback_data(
254
 
                subreq, struct tevent_req);
255
 
        struct resp_read_state *state = tevent_req_data(
256
 
                req, struct resp_read_state);
257
 
        uint8_t *buf;
258
 
        int err;
259
 
 
260
 
        state->ret = read_packet_recv(subreq, state, &buf, &err);
261
 
        TALLOC_FREE(subreq);
262
 
        if (state->ret == -1) {
263
 
                tevent_req_error(req, err);
264
 
                return;
265
 
        }
266
 
 
267
 
        state->wb_resp = (struct winbindd_response *)buf;
268
 
 
269
 
        if (state->wb_resp->length > sizeof(struct winbindd_response)) {
270
 
                state->wb_resp->extra_data.data =
271
 
                        (char *)buf + sizeof(struct winbindd_response);
272
 
        } else {
273
 
                state->wb_resp->extra_data.data = NULL;
274
 
        }
275
 
        tevent_req_done(req);
276
 
}
277
 
 
278
 
ssize_t wb_resp_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
279
 
                          struct winbindd_response **presp, int *err)
280
 
{
281
 
        struct resp_read_state *state = tevent_req_data(
282
 
                req, struct resp_read_state);
283
 
 
284
 
        if (tevent_req_is_unix_error(req, err)) {
285
 
                return -1;
286
 
        }
287
 
        *presp = talloc_move(mem_ctx, &state->wb_resp);
288
 
        return state->ret;
289
 
}
290
 
 
291
 
struct resp_write_state {
292
 
        struct iovec iov[2];
293
 
        ssize_t ret;
294
 
};
295
 
 
296
 
static void wb_resp_write_done(struct tevent_req *subreq);
297
 
 
298
 
struct tevent_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
299
 
                                      struct tevent_context *ev,
300
 
                                      struct tevent_queue *queue, int fd,
301
 
                                      struct winbindd_response *wb_resp)
302
 
{
303
 
        struct tevent_req *req, *subreq;
304
 
        struct resp_write_state *state;
305
 
        int count = 1;
306
 
 
307
 
        req = tevent_req_create(mem_ctx, &state, struct resp_write_state);
308
 
        if (req == NULL) {
309
 
                return NULL;
310
 
        }
311
 
 
312
 
        state->iov[0].iov_base = (void *)wb_resp;
313
 
        state->iov[0].iov_len = sizeof(struct winbindd_response);
314
 
 
315
 
        if (wb_resp->length > sizeof(struct winbindd_response)) {
316
 
                state->iov[1].iov_base = (void *)wb_resp->extra_data.data;
317
 
                state->iov[1].iov_len =
318
 
                        wb_resp->length - sizeof(struct winbindd_response);
319
 
                count = 2;
320
 
        }
321
 
 
322
 
        subreq = writev_send(state, ev, queue, fd, true, state->iov, count);
323
 
        if (tevent_req_nomem(subreq, req)) {
324
 
                return tevent_req_post(req, ev);
325
 
        }
326
 
        tevent_req_set_callback(subreq, wb_resp_write_done, req);
327
 
        return req;
328
 
}
329
 
 
330
 
static void wb_resp_write_done(struct tevent_req *subreq)
331
 
{
332
 
        struct tevent_req *req = tevent_req_callback_data(
333
 
                subreq, struct tevent_req);
334
 
        struct resp_write_state *state = tevent_req_data(
335
 
                req, struct resp_write_state);
336
 
        int err;
337
 
 
338
 
        state->ret = writev_recv(subreq, &err);
339
 
        TALLOC_FREE(subreq);
340
 
        if (state->ret < 0) {
341
 
                tevent_req_error(req, err);
342
 
                return;
343
 
        }
344
 
        tevent_req_done(req);
345
 
}
346
 
 
347
 
ssize_t wb_resp_write_recv(struct tevent_req *req, int *err)
348
 
{
349
 
        struct resp_write_state *state = tevent_req_data(
350
 
                req, struct resp_write_state);
351
 
 
352
 
        if (tevent_req_is_unix_error(req, err)) {
353
 
                return -1;
354
 
        }
355
 
        return state->ret;
356
 
}
357
 
 
358
 
struct wb_simple_trans_state {
359
 
        struct tevent_context *ev;
360
 
        int fd;
361
 
        struct winbindd_response *wb_resp;
362
 
};
363
 
 
364
 
static void wb_simple_trans_write_done(struct tevent_req *subreq);
365
 
static void wb_simple_trans_read_done(struct tevent_req *subreq);
366
 
 
367
 
struct tevent_req *wb_simple_trans_send(TALLOC_CTX *mem_ctx,
368
 
                                        struct tevent_context *ev,
369
 
                                        struct tevent_queue *queue, int fd,
370
 
                                        struct winbindd_request *wb_req)
371
 
{
372
 
        struct tevent_req *req, *subreq;
373
 
        struct wb_simple_trans_state *state;
374
 
 
375
 
        req = tevent_req_create(mem_ctx, &state, struct wb_simple_trans_state);
376
 
        if (req == NULL) {
377
 
                return NULL;
378
 
        }
379
 
 
380
 
        wb_req->length = sizeof(struct winbindd_request);
381
 
 
382
 
        state->ev = ev;
383
 
        state->fd = fd;
384
 
 
385
 
        subreq = wb_req_write_send(state, ev, queue, fd, wb_req);
386
 
        if (tevent_req_nomem(subreq, req)) {
387
 
                return tevent_req_post(req, ev);
388
 
        }
389
 
        tevent_req_set_callback(subreq, wb_simple_trans_write_done, req);
390
 
 
391
 
        return req;
392
 
}
393
 
 
394
 
static void wb_simple_trans_write_done(struct tevent_req *subreq)
395
 
{
396
 
        struct tevent_req *req = tevent_req_callback_data(
397
 
                subreq, struct tevent_req);
398
 
        struct wb_simple_trans_state *state = tevent_req_data(
399
 
                req, struct wb_simple_trans_state);
400
 
        ssize_t ret;
401
 
        int err;
402
 
 
403
 
        ret = wb_req_write_recv(subreq, &err);
404
 
        TALLOC_FREE(subreq);
405
 
        if (ret == -1) {
406
 
                tevent_req_error(req, err);
407
 
                return;
408
 
        }
409
 
        subreq = wb_resp_read_send(state, state->ev, state->fd);
410
 
        if (tevent_req_nomem(subreq, req)) {
411
 
                return;
412
 
        }
413
 
        tevent_req_set_callback(subreq, wb_simple_trans_read_done, req);
414
 
}
415
 
 
416
 
static void wb_simple_trans_read_done(struct tevent_req *subreq)
417
 
{
418
 
        struct tevent_req *req = tevent_req_callback_data(
419
 
                subreq, struct tevent_req);
420
 
        struct wb_simple_trans_state *state = tevent_req_data(
421
 
                req, struct wb_simple_trans_state);
422
 
        ssize_t ret;
423
 
        int err;
424
 
 
425
 
        ret = wb_resp_read_recv(subreq, state, &state->wb_resp, &err);
426
 
        TALLOC_FREE(subreq);
427
 
        if (ret == -1) {
428
 
                tevent_req_error(req, err);
429
 
                return;
430
 
        }
431
 
 
432
 
        tevent_req_done(req);
433
 
}
434
 
 
435
 
int wb_simple_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
436
 
                         struct winbindd_response **presponse, int *err)
437
 
{
438
 
        struct wb_simple_trans_state *state = tevent_req_data(
439
 
                req, struct wb_simple_trans_state);
440
 
 
441
 
        if (tevent_req_is_unix_error(req, err)) {
442
 
                return -1;
443
 
        }
444
 
        *presponse = talloc_move(mem_ctx, &state->wb_resp);
445
 
        return 0;
446
 
}