Ignore:
Timestamp:
Nov 14, 2012, 12:59:34 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to 3.6.0

File:
1 edited

Legend:

Unmodified
Added
Removed
  • vendor/current/source4/libnet/userinfo.c

    r414 r740  
    4646
    4747
    48 static void continue_userinfo_lookup(struct rpc_request *req);
    49 static void continue_userinfo_openuser(struct rpc_request *req);
    50 static void continue_userinfo_getuser(struct rpc_request *req);
    51 static void continue_userinfo_closeuser(struct rpc_request *req);
     48static void continue_userinfo_lookup(struct tevent_req *subreq);
     49static void continue_userinfo_openuser(struct tevent_req *subreq);
     50static void continue_userinfo_getuser(struct tevent_req *subreq);
     51static void continue_userinfo_closeuser(struct tevent_req *subreq);
    5252
    5353
     
    5555 * Stage 1 (optional): Look for a username in SAM server.
    5656 */
    57 static void continue_userinfo_lookup(struct rpc_request *req)
    58 {
    59         struct composite_context *c;
    60         struct userinfo_state *s;
    61         struct rpc_request *openuser_req;
     57static void continue_userinfo_lookup(struct tevent_req *subreq)
     58{
     59        struct composite_context *c;
     60        struct userinfo_state *s;
    6261        struct monitor_msg msg;
    6362        struct msg_rpc_lookup_name *msg_lookup;
    6463
    65         c = talloc_get_type(req->async.private_data, struct composite_context);
     64        c = tevent_req_callback_data(subreq, struct composite_context);
    6665        s = talloc_get_type(c->private_data, struct userinfo_state);
    6766
    6867        /* receive samr_Lookup reply */
    69         c->status = dcerpc_ndr_request_recv(req);
     68        c->status = dcerpc_samr_LookupNames_r_recv(subreq, s);
     69        TALLOC_FREE(subreq);
    7070        if (!composite_is_ok(c)) return;
    7171       
     
    104104
    105105        /* send request */
    106         openuser_req = dcerpc_samr_OpenUser_send(s->pipe, c, &s->openuser);
    107         if (composite_nomem(openuser_req, c)) return;
    108 
    109         composite_continue_rpc(c, openuser_req, continue_userinfo_openuser, c);
     106        subreq = dcerpc_samr_OpenUser_r_send(s, c->event_ctx,
     107                                             s->pipe->binding_handle,
     108                                             &s->openuser);
     109        if (composite_nomem(subreq, c)) return;
     110
     111        tevent_req_set_callback(subreq, continue_userinfo_openuser, c);
    110112}
    111113
     
    114116 * Stage 2: Open user policy handle.
    115117 */
    116 static void continue_userinfo_openuser(struct rpc_request *req)
    117 {
    118         struct composite_context *c;
    119         struct userinfo_state *s;
    120         struct rpc_request *queryuser_req;
     118static void continue_userinfo_openuser(struct tevent_req *subreq)
     119{
     120        struct composite_context *c;
     121        struct userinfo_state *s;
    121122        struct monitor_msg msg;
    122123        struct msg_rpc_open_user *msg_open;
    123124
    124         c = talloc_get_type(req->async.private_data, struct composite_context);
     125        c = tevent_req_callback_data(subreq, struct composite_context);
    125126        s = talloc_get_type(c->private_data, struct userinfo_state);
    126127
    127128        /* receive samr_OpenUser reply */
    128         c->status = dcerpc_ndr_request_recv(req);
     129        c->status = dcerpc_samr_OpenUser_r_recv(subreq, s);
     130        TALLOC_FREE(subreq);
    129131        if (!composite_is_ok(c)) return;
    130132
     
    153155       
    154156        /* queue rpc call, set event handling and new state */
    155         queryuser_req = dcerpc_samr_QueryUserInfo_send(s->pipe, c, &s->queryuserinfo);
    156         if (composite_nomem(queryuser_req, c)) return;
    157        
    158         composite_continue_rpc(c, queryuser_req, continue_userinfo_getuser, c);
     157        subreq = dcerpc_samr_QueryUserInfo_r_send(s, c->event_ctx,
     158                                                  s->pipe->binding_handle,
     159                                                  &s->queryuserinfo);
     160        if (composite_nomem(subreq, c)) return;
     161       
     162        tevent_req_set_callback(subreq, continue_userinfo_getuser, c);
    159163}
    160164
     
    163167 * Stage 3: Get requested user information.
    164168 */
    165 static void continue_userinfo_getuser(struct rpc_request *req)
    166 {
    167         struct composite_context *c;
    168         struct userinfo_state *s;
    169         struct rpc_request *close_req;
     169static void continue_userinfo_getuser(struct tevent_req *subreq)
     170{
     171        struct composite_context *c;
     172        struct userinfo_state *s;
    170173        struct monitor_msg msg;
    171174        struct msg_rpc_query_user *msg_query;
    172175
    173         c = talloc_get_type(req->async.private_data, struct composite_context);
     176        c = tevent_req_callback_data(subreq, struct composite_context);
    174177        s = talloc_get_type(c->private_data, struct userinfo_state);
    175178
    176179        /* receive samr_QueryUserInfo reply */
    177         c->status = dcerpc_ndr_request_recv(req);
     180        c->status = dcerpc_samr_QueryUserInfo_r_recv(subreq, s);
     181        TALLOC_FREE(subreq);
    178182        if (!composite_is_ok(c)) return;
    179183
     
    202206       
    203207        /* queue rpc call, set event handling and new state */
    204         close_req = dcerpc_samr_Close_send(s->pipe, c, &s->samrclose);
    205         if (composite_nomem(close_req, c)) return;
    206        
    207         composite_continue_rpc(c, close_req, continue_userinfo_closeuser, c);
     208        subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
     209                                          s->pipe->binding_handle,
     210                                          &s->samrclose);
     211        if (composite_nomem(subreq, c)) return;
     212       
     213        tevent_req_set_callback(subreq, continue_userinfo_closeuser, c);
    208214}
    209215
     
    212218 * Stage 4: Close policy handle associated with opened user.
    213219 */
    214 static void continue_userinfo_closeuser(struct rpc_request *req)
     220static void continue_userinfo_closeuser(struct tevent_req *subreq)
    215221{
    216222        struct composite_context *c;
     
    219225        struct msg_rpc_close_user *msg_close;
    220226
    221         c = talloc_get_type(req->async.private_data, struct composite_context);
     227        c = tevent_req_callback_data(subreq, struct composite_context);
    222228        s = talloc_get_type(c->private_data, struct userinfo_state);
    223229
    224230        /* receive samr_Close reply */
    225         c->status = dcerpc_ndr_request_recv(req);
     231        c->status = dcerpc_samr_Close_r_recv(subreq, s);
     232        TALLOC_FREE(subreq);
    226233        if (!composite_is_ok(c)) return;
    227234
     
    259266        struct userinfo_state *s;
    260267        struct dom_sid *sid;
    261         struct rpc_request *openuser_req, *lookup_req;
     268        struct tevent_req *subreq;
    262269
    263270        if (!p || !io) return NULL;
     
    286293               
    287294                /* send request */
    288                 openuser_req = dcerpc_samr_OpenUser_send(p, c, &s->openuser);
    289                 if (composite_nomem(openuser_req, c)) return c;
    290 
    291                 composite_continue_rpc(c, openuser_req, continue_userinfo_openuser, c);
     295                subreq = dcerpc_samr_OpenUser_r_send(s, c->event_ctx,
     296                                                     p->binding_handle,
     297                                                     &s->openuser);
     298                if (composite_nomem(subreq, c)) return c;
     299
     300                tevent_req_set_callback(subreq, continue_userinfo_openuser, c);
    292301
    293302        } else {
     
    306315               
    307316                /* send request */
    308                 lookup_req = dcerpc_samr_LookupNames_send(p, c, &s->lookup);
    309                 if (composite_nomem(lookup_req, c)) return c;
    310                
    311                 composite_continue_rpc(c, lookup_req, continue_userinfo_lookup, c);
     317                subreq = dcerpc_samr_LookupNames_r_send(s, c->event_ctx,
     318                                                        p->binding_handle,
     319                                                        &s->lookup);
     320                if (composite_nomem(subreq, c)) return c;
     321               
     322                tevent_req_set_callback(subreq, continue_userinfo_lookup, c);
    312323        }
    313324
Note: See TracChangeset for help on using the changeset viewer.