Ignore:
Timestamp:
Nov 27, 2012, 4:43:17 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: updated trunk to 3.6.0

Location:
trunk/server
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source4/libnet/libnet_domain.c

    r414 r745  
    4848
    4949
    50 static void continue_domain_open_close(struct rpc_request *req);
    51 static void continue_domain_open_connect(struct rpc_request *req);
    52 static void continue_domain_open_lookup(struct rpc_request *req);
    53 static void continue_domain_open_open(struct rpc_request *req);
     50static void continue_domain_open_close(struct tevent_req *subreq);
     51static void continue_domain_open_connect(struct tevent_req *subreq);
     52static void continue_domain_open_lookup(struct tevent_req *subreq);
     53static void continue_domain_open_open(struct tevent_req *subreq);
    5454
    5555
    … …  
    6161        struct composite_context *c;
    6262        struct domain_open_samr_state *s;
    63         struct rpc_request *conn_req;
     63        struct tevent_req *subreq;
    6464
    6565        c = talloc_get_type(ctx->async.private_data, struct composite_context);
    … …  
    7777
    7878        /* send request */
    79         conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
    80         if (composite_nomem(conn_req, c)) return;
     79        subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
     80                                            s->pipe->binding_handle,
     81                                            &s->connect);
     82        if (composite_nomem(subreq, c)) return;
    8183
    8284        /* callback handler */
    83         composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
     85        tevent_req_set_callback(subreq, continue_domain_open_connect, c);
    8486}
    8587
    … …  
    8991 * handle
    9092 */
    91 static void continue_domain_open_close(struct rpc_request *req)
     93static void continue_domain_open_close(struct tevent_req *subreq)
    9294{
    9395        struct composite_context *c;
    9496        struct domain_open_samr_state *s;
    95         struct rpc_request *conn_req;
    96 
    97         c = talloc_get_type(req->async.private_data, struct composite_context);
     97
     98        c = tevent_req_callback_data(subreq, struct composite_context);
    9899        s = talloc_get_type(c->private_data, struct domain_open_samr_state);
    99100
    100101        /* receive samr_Close reply */
    101         c->status = dcerpc_ndr_request_recv(req);
     102        c->status = dcerpc_samr_Close_r_recv(subreq, s);
     103        TALLOC_FREE(subreq);
    102104        if (!composite_is_ok(c)) return;
    103105
    … …  
    122124       
    123125        /* send request */
    124         conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
    125         if (composite_nomem(conn_req, c)) return;
     126        subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
     127                                            s->pipe->binding_handle,
     128                                            &s->connect);
     129        if (composite_nomem(subreq, c)) return;
    126130
    127131        /* callback handler */
    128         composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
     132        tevent_req_set_callback(subreq, continue_domain_open_connect, c);
    129133}
    130134
    … …  
    133137 * Stage 1: Connect to SAM server.
    134138 */
    135 static void continue_domain_open_connect(struct rpc_request *req)
     139static void continue_domain_open_connect(struct tevent_req *subreq)
    136140{
    137141        struct composite_context *c;
    138142        struct domain_open_samr_state *s;
    139         struct rpc_request *lookup_req;
    140143        struct samr_LookupDomain *r;
    141144       
    142         c = talloc_get_type(req->async.private_data, struct composite_context);
     145        c = tevent_req_callback_data(subreq, struct composite_context);
    143146        s = talloc_get_type(c->private_data, struct domain_open_samr_state);
    144147
    145148        /* receive samr_Connect reply */
    146         c->status = dcerpc_ndr_request_recv(req);
     149        c->status = dcerpc_samr_Connect_r_recv(subreq, s);
     150        TALLOC_FREE(subreq);
    147151        if (!composite_is_ok(c)) return;
    148152
    … …  
    164168        if (composite_nomem(r->out.sid, c)) return;
    165169
    166         lookup_req = dcerpc_samr_LookupDomain_send(s->pipe, c, r);
    167         if (composite_nomem(lookup_req, c)) return;
    168 
    169         composite_continue_rpc(c, lookup_req, continue_domain_open_lookup, c);
     170        subreq = dcerpc_samr_LookupDomain_r_send(s, c->event_ctx,
     171                                                 s->pipe->binding_handle,
     172                                                 r);
     173        if (composite_nomem(subreq, c)) return;
     174
     175        tevent_req_set_callback(subreq, continue_domain_open_lookup, c);
    170176}
    171177
    … …  
    174180 * Stage 2: Lookup domain by name.
    175181 */
    176 static void continue_domain_open_lookup(struct rpc_request *req)
     182static void continue_domain_open_lookup(struct tevent_req *subreq)
    177183{
    178184        struct composite_context *c;
    179185        struct domain_open_samr_state *s;
    180         struct rpc_request *opendom_req;
    181186        struct samr_OpenDomain *r;
    182187
    183         c = talloc_get_type(req->async.private_data, struct composite_context);
     188        c = tevent_req_callback_data(subreq, struct composite_context);
    184189        s = talloc_get_type(c->private_data, struct domain_open_samr_state);
    185190       
    186191        /* receive samr_LookupDomain reply */
    187         c->status = dcerpc_ndr_request_recv(req);
     192        c->status = dcerpc_samr_LookupDomain_r_recv(subreq, s);
     193        TALLOC_FREE(subreq);
    188194
    189195        if (s->monitor_fn) {
    … …  
    216222        r->out.domain_handle = &s->domain_handle;
    217223
    218         opendom_req = dcerpc_samr_OpenDomain_send(s->pipe, c, r);
    219         if (composite_nomem(opendom_req, c)) return;
    220 
    221         composite_continue_rpc(c, opendom_req, continue_domain_open_open, c);
     224        subreq = dcerpc_samr_OpenDomain_r_send(s, c->event_ctx,
     225                                               s->pipe->binding_handle,
     226                                               r);
     227        if (composite_nomem(subreq, c)) return;
     228
     229        tevent_req_set_callback(subreq, continue_domain_open_open, c);
    222230}
    223231
    … …  
    226234 * Stage 3: Open domain.
    227235 */
    228 static void continue_domain_open_open(struct rpc_request *req)
     236static void continue_domain_open_open(struct tevent_req *subreq)
    229237{
    230238        struct composite_context *c;
    231239        struct domain_open_samr_state *s;
    232240
    233         c = talloc_get_type(req->async.private_data, struct composite_context);
     241        c = tevent_req_callback_data(subreq, struct composite_context);
    234242        s = talloc_get_type(c->private_data, struct domain_open_samr_state);
    235243
    236244        /* receive samr_OpenDomain reply */
    237         c->status = dcerpc_ndr_request_recv(req);
     245        c->status = dcerpc_samr_OpenDomain_r_recv(subreq, s);
     246        TALLOC_FREE(subreq);
    238247        if (!composite_is_ok(c)) return;
    239248
    … …  
    266275        struct domain_open_samr_state *s;
    267276        struct composite_context *rpcconn_req;
    268         struct rpc_request *close_req, *conn_req;
     277        struct tevent_req *subreq;
    269278
    270279        c = composite_create(ctx, ctx->event_ctx);
    … …  
    314323
    315324                        /* send request to close domain handle */
    316                         close_req = dcerpc_samr_Close_send(s->pipe, c, &s->close);
    317                         if (composite_nomem(close_req, c)) return c;
     325                        subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
     326                                                          s->pipe->binding_handle,
     327                                                          &s->close);
     328                        if (composite_nomem(subreq, c)) return c;
    318329
    319330                        /* callback handler */
    320                         composite_continue_rpc(c, close_req, continue_domain_open_close, c);
     331                        tevent_req_set_callback(subreq, continue_domain_open_close, c);
    321332                        return c;
    322333                }
    … …  
    329340       
    330341        /* send request */
    331         conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
    332         if (composite_nomem(conn_req, c)) return c;
     342        subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
     343                                            s->pipe->binding_handle,
     344                                            &s->connect);
     345        if (composite_nomem(subreq, c)) return c;
    333346
    334347        /* callback handler */
    335         composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
     348        tevent_req_set_callback(subreq, continue_domain_open_connect, c);
    336349        return c;
    337350}
    … …  
    390403
    391404static void continue_rpc_connect_lsa(struct composite_context *ctx);
    392 static void continue_lsa_policy_open(struct rpc_request *req);
     405static void continue_lsa_policy_open(struct tevent_req *subreq);
    393406
    394407
    … …  
    408421        struct domain_open_lsa_state *s;
    409422        struct composite_context *rpcconn_req;
    410         struct rpc_request *openpol_req;
     423        struct tevent_req *subreq;
    411424        struct lsa_QosInfo *qos;
    412425
    … …  
    460473       
    461474        /* send rpc request */
    462         openpol_req = dcerpc_lsa_OpenPolicy2_send(s->pipe, c, &s->openpol);
    463         if (composite_nomem(openpol_req, c)) return c;
    464 
    465         composite_continue_rpc(c, openpol_req, continue_lsa_policy_open, c);
     475        subreq = dcerpc_lsa_OpenPolicy2_r_send(s, c->event_ctx,
     476                                               s->pipe->binding_handle,
     477                                               &s->openpol);
     478        if (composite_nomem(subreq, c)) return c;
     479
     480        tevent_req_set_callback(subreq, continue_lsa_policy_open, c);
    466481        return c;
    467482}
    … …  
    476491        struct domain_open_lsa_state *s;
    477492        struct lsa_QosInfo *qos;
    478         struct rpc_request *openpol_req;
     493        struct tevent_req *subreq;
    479494
    480495        c = talloc_get_type(ctx->async.private_data, struct composite_context);
    … …  
    504519
    505520        /* send rpc request */
    506         openpol_req = dcerpc_lsa_OpenPolicy2_send(s->pipe, c, &s->openpol);
    507         if (composite_nomem(openpol_req, c)) return;
    508 
    509         composite_continue_rpc(c, openpol_req, continue_lsa_policy_open, c);
     521        subreq = dcerpc_lsa_OpenPolicy2_r_send(s, c->event_ctx,
     522                                               s->pipe->binding_handle,
     523                                               &s->openpol);
     524        if (composite_nomem(subreq, c)) return;
     525
     526        tevent_req_set_callback(subreq, continue_lsa_policy_open, c);
    510527}
    511528
    … …  
    514531  Stage 1: Lsa policy opened - we're done, if successfully
    515532 */
    516 static void continue_lsa_policy_open(struct rpc_request *req)
     533static void continue_lsa_policy_open(struct tevent_req *subreq)
    517534{
    518535        struct composite_context *c;
    519536        struct domain_open_lsa_state *s;
    520537
    521         c = talloc_get_type(req->async.private_data, struct composite_context);
     538        c = tevent_req_callback_data(subreq, struct composite_context);
    522539        s = talloc_get_type(c->private_data, struct domain_open_lsa_state);
    523540
    524         c->status = dcerpc_ndr_request_recv(req);
     541        c->status = dcerpc_lsa_OpenPolicy2_r_recv(subreq, s);
     542        TALLOC_FREE(subreq);
    525543        if (!composite_is_ok(c)) return;
    526544
    … …  
    667685
    668686
    669 static void continue_lsa_close(struct rpc_request *req);
     687static void continue_lsa_close(struct tevent_req *subreq);
    670688
    671689
    … …  
    676694        struct composite_context *c;
    677695        struct domain_close_lsa_state *s;
    678         struct rpc_request *close_req;
     696        struct tevent_req *subreq;
    679697
    680698        /* composite context and state structure allocation */
    … …  
    703721
    704722        /* send the request */
    705         close_req = dcerpc_lsa_Close_send(s->pipe, c, &s->close);
    706         if (composite_nomem(close_req, c)) return c;
    707 
    708         composite_continue_rpc(c, close_req, continue_lsa_close, c);
     723        subreq = dcerpc_lsa_Close_r_send(s, c->event_ctx,
     724                                         s->pipe->binding_handle,
     725                                         &s->close);
     726        if (composite_nomem(subreq, c)) return c;
     727
     728        tevent_req_set_callback(subreq, continue_lsa_close, c);
    709729        return c;
    710730}
    … …  
    714734  Stage 1: Receive result of lsa close call
    715735*/
    716 static void continue_lsa_close(struct rpc_request *req)
     736static void continue_lsa_close(struct tevent_req *subreq)
    717737{
    718738        struct composite_context *c;
    719739        struct domain_close_lsa_state *s;
    720740       
    721         c = talloc_get_type(req->async.private_data, struct composite_context);
     741        c = tevent_req_callback_data(subreq, struct composite_context);
    722742        s = talloc_get_type(c->private_data, struct domain_close_lsa_state);
    723743
    724         c->status = dcerpc_ndr_request_recv(req);
     744        c->status = dcerpc_lsa_Close_r_recv(subreq, s);
     745        TALLOC_FREE(subreq);
    725746        if (!composite_is_ok(c)) return;
    726747
    … …  
    771792
    772793
    773 static void continue_samr_close(struct rpc_request *req);
     794static void continue_samr_close(struct tevent_req *subreq);
    774795
    775796
    … …  
    780801        struct composite_context *c;
    781802        struct domain_close_samr_state *s;
    782         struct rpc_request *close_req;
     803        struct tevent_req *subreq;
    783804
    784805        /* composite context and state structure allocation */
    … …  
    805826
    806827        /* send the request */
    807         close_req = dcerpc_samr_Close_send(ctx->samr.pipe, ctx, &s->close);
    808         if (composite_nomem(close_req, c)) return c;
    809 
    810         composite_continue_rpc(c, close_req, continue_samr_close, c);
     828        subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
     829                                          ctx->samr.pipe->binding_handle,
     830                                          &s->close);
     831        if (composite_nomem(subreq, c)) return c;
     832
     833        tevent_req_set_callback(subreq, continue_samr_close, c);
    811834        return c;
    812835}
    … …  
    816839  Stage 1: Receive result of samr close call
    817840*/
    818 static void continue_samr_close(struct rpc_request *req)
     841static void continue_samr_close(struct tevent_req *subreq)
    819842{
    820843        struct composite_context *c;
    821844        struct domain_close_samr_state *s;
    822845
    823         c = talloc_get_type(req->async.private_data, struct composite_context);
     846        c = tevent_req_callback_data(subreq, struct composite_context);
    824847        s = talloc_get_type(c->private_data, struct domain_close_samr_state);
    825848       
    826         c->status = dcerpc_ndr_request_recv(req);
     849        c->status = dcerpc_samr_Close_r_recv(subreq, s);
     850        TALLOC_FREE(subreq);
    827851        if (!composite_is_ok(c)) return;
    828852
    … …  
    941965
    942966static void continue_rpc_connect(struct composite_context *c);
    943 static void continue_samr_connect(struct rpc_request *c);
    944 static void continue_samr_enum_domains(struct rpc_request *req);
    945 static void continue_samr_close_handle(struct rpc_request *req);
     967static void continue_samr_connect(struct tevent_req *subreq);
     968static void continue_samr_enum_domains(struct tevent_req *subreq);
     969static void continue_samr_close_handle(struct tevent_req *subreq);
    946970
    947971static struct domainlist* get_domain_list(TALLOC_CTX *mem_ctx, struct domain_list_state *s);
    … …  
    956980        struct composite_context *c;
    957981        struct domain_list_state *s;
    958         struct rpc_request *samrconn_req;
     982        struct tevent_req *subreq;
    959983
    960984        c = talloc_get_type(ctx->async.private_data, struct composite_context);
    … …  
    968992        s->samrconn.out.connect_handle = &s->connect_handle;
    969993
    970         samrconn_req = dcerpc_samr_Connect_send(s->ctx->samr.pipe, c, &s->samrconn);
    971         if (composite_nomem(samrconn_req, c)) return;
    972 
    973         composite_continue_rpc(c, samrconn_req, continue_samr_connect, c);
     994        subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
     995                                            s->ctx->samr.pipe->binding_handle,
     996                                            &s->samrconn);
     997        if (composite_nomem(subreq, c)) return;
     998
     999        tevent_req_set_callback(subreq, continue_samr_connect, c);
    9741000}
    9751001
    … …  
    9791005  a request to enumerate domain databases available
    9801006*/
    981 static void continue_samr_connect(struct rpc_request *req)
     1007static void continue_samr_connect(struct tevent_req *subreq)
    9821008{
    9831009        struct composite_context *c;
    9841010        struct domain_list_state *s;
    985         struct rpc_request *enumdom_req;
    986 
    987         c = talloc_get_type(req->async.private_data, struct composite_context);
     1011
     1012        c = tevent_req_callback_data(subreq, struct composite_context);
    9881013        s = talloc_get_type(c->private_data, struct domain_list_state);
    9891014       
    990         c->status = dcerpc_ndr_request_recv(req);
     1015        c->status = dcerpc_samr_Connect_r_recv(subreq, s);
     1016        TALLOC_FREE(subreq);
    9911017        if (!composite_is_ok(c)) return;
    9921018
    … …  
    10091035        if (composite_nomem(s->enumdom.out.sam, c)) return;
    10101036
    1011         enumdom_req = dcerpc_samr_EnumDomains_send(s->ctx->samr.pipe, c, &s->enumdom);
    1012         if (composite_nomem(enumdom_req, c)) return;
    1013 
    1014         composite_continue_rpc(c, enumdom_req, continue_samr_enum_domains, c);
     1037        subreq = dcerpc_samr_EnumDomains_r_send(s, c->event_ctx,
     1038                                                s->ctx->samr.pipe->binding_handle,
     1039                                                &s->enumdom);
     1040        if (composite_nomem(subreq, c)) return;
     1041
     1042        tevent_req_set_callback(subreq, continue_samr_enum_domains, c);
    10151043}
    10161044
    … …  
    10211049  upon completion.
    10221050*/
    1023 static void continue_samr_enum_domains(struct rpc_request *req)
     1051static void continue_samr_enum_domains(struct tevent_req *subreq)
    10241052{
    10251053        struct composite_context *c;
    10261054        struct domain_list_state *s;
    1027         struct rpc_request *enumdom_req;
    1028         struct rpc_request *samrclose_req;
    1029 
    1030         c = talloc_get_type(req->async.private_data, struct composite_context);
     1055
     1056        c = tevent_req_callback_data(subreq, struct composite_context);
    10311057        s = talloc_get_type(c->private_data, struct domain_list_state);
    10321058       
    1033         c->status = dcerpc_ndr_request_recv(req);
     1059        c->status = dcerpc_samr_EnumDomains_r_recv(subreq, s);
     1060        TALLOC_FREE(subreq);
    10341061        if (!composite_is_ok(c)) return;
    10351062
    … …  
    10581085
    10591086                /* send the request */
    1060                 enumdom_req = dcerpc_samr_EnumDomains_send(s->ctx->samr.pipe, c, &s->enumdom);
    1061                 if (composite_nomem(enumdom_req, c)) return;
    1062 
    1063                 composite_continue_rpc(c, enumdom_req, continue_samr_enum_domains, c);
     1087                subreq = dcerpc_samr_EnumDomains_r_send(s, c->event_ctx,
     1088                                                        s->ctx->samr.pipe->binding_handle,
     1089                                                        &s->enumdom);
     1090                if (composite_nomem(subreq, c)) return;
     1091
     1092                tevent_req_set_callback(subreq, continue_samr_enum_domains, c);
    10641093
    10651094        } else {
    … …  
    10731102       
    10741103        /* send the request */
    1075         samrclose_req = dcerpc_samr_Close_send(s->ctx->samr.pipe, c, &s->samrclose);
    1076         if (composite_nomem(samrclose_req, c)) return;
    1077 
    1078         composite_continue_rpc(c, samrclose_req, continue_samr_close_handle, c);
     1104        subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
     1105                                          s->ctx->samr.pipe->binding_handle,
     1106                                          &s->samrclose);
     1107        if (composite_nomem(subreq, c)) return;
     1108
     1109        tevent_req_set_callback(subreq, continue_samr_close_handle, c);
    10791110}
    10801111
    … …  
    10831114  Stage 4: Receive result of closing samr connection handle.
    10841115*/
    1085 static void continue_samr_close_handle(struct rpc_request *req)
     1116static void continue_samr_close_handle(struct tevent_req *subreq)
    10861117{
    10871118        struct composite_context *c;
    10881119        struct domain_list_state *s;
    10891120
    1090         c = talloc_get_type(req->async.private_data, struct composite_context);
     1121        c = tevent_req_callback_data(subreq, struct composite_context);
    10911122        s = talloc_get_type(c->private_data, struct domain_list_state);
    10921123
    1093         c->status = dcerpc_ndr_request_recv(req);
     1124        c->status = dcerpc_samr_Close_r_recv(subreq, s);
     1125        TALLOC_FREE(subreq);
    10941126        if (!composite_is_ok(c)) return;
    10951127
    … …  
    11171149static struct domainlist* get_domain_list(TALLOC_CTX *mem_ctx, struct domain_list_state *s)
    11181150{
    1119         int i;
     1151        uint32_t i;
    11201152        if (mem_ctx == NULL || s == NULL) return NULL;
    11211153
    … …  
    11641196        struct domain_list_state *s;
    11651197        struct composite_context *rpcconn_req;
    1166         struct rpc_request *samrconn_req;
     1198        struct tevent_req *subreq;
    11671199
    11681200        /* composite context and state structure allocation */
    … …  
    12001232                s->samrconn.out.connect_handle = &s->connect_handle;
    12011233               
    1202                 samrconn_req = dcerpc_samr_Connect_send(s->ctx->samr.pipe, c, &s->samrconn);
    1203                 if (composite_nomem(samrconn_req, c)) return c;
    1204 
    1205                 composite_continue_rpc(c, samrconn_req, continue_samr_connect, c);
     1234                subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
     1235                                                    s->ctx->samr.pipe->binding_handle,
     1236                                                    &s->samrconn);
     1237                if (composite_nomem(subreq, c)) return c;
     1238
     1239                tevent_req_set_callback(subreq, continue_samr_connect, c);
    12061240        }
    12071241
Note: See TracChangeset for help on using the changeset viewer.