Ignore:
Timestamp:
Jun 9, 2016, 2:23:12 PM (10 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: apply latest security patches to trunk

Location:
trunk/server
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source3/rpc_server/dfs/srv_dfs_nt.c

    r918 r920  
    412412{
    413413        /* FIXME: Implement your code here */
    414         p->rng_fault_state = True;
     414        p->;
    415415        return WERR_NOT_SUPPORTED;
    416416}
    … …  
    419419{
    420420        /* FIXME: Implement your code here */
    421         p->rng_fault_state = True;
     421        p->;
    422422        return WERR_NOT_SUPPORTED;
    423423}
    … …  
    426426{
    427427        /* FIXME: Implement your code here */
    428         p->rng_fault_state = True;
     428        p->;
    429429        return WERR_NOT_SUPPORTED;
    430430}
    … …  
    433433{
    434434        /* FIXME: Implement your code here */
    435         p->rng_fault_state = True;
     435        p->;
    436436        return WERR_NOT_SUPPORTED;
    437437}
    … …  
    440440{
    441441        /* FIXME: Implement your code here */
    442         p->rng_fault_state = True;
     442        p->;
    443443        return WERR_NOT_SUPPORTED;
    444444}
    … …  
    447447{
    448448        /* FIXME: Implement your code here */
    449         p->rng_fault_state = True;
     449        p->;
    450450        return WERR_NOT_SUPPORTED;
    451451}
    … …  
    454454{
    455455        /* FIXME: Implement your code here */
    456         p->rng_fault_state = True;
     456        p->;
    457457        return WERR_NOT_SUPPORTED;
    458458}
    … …  
    461461{
    462462        /* FIXME: Implement your code here */
    463         p->rng_fault_state = True;
     463        p->;
    464464        return WERR_NOT_SUPPORTED;
    465465}
    … …  
    468468{
    469469        /* FIXME: Implement your code here */
    470         p->rng_fault_state = True;
     470        p->;
    471471        return WERR_NOT_SUPPORTED;
    472472}
    … …  
    475475{
    476476        /* FIXME: Implement your code here */
    477         p->rng_fault_state = True;
     477        p->;
    478478        return WERR_NOT_SUPPORTED;
    479479}
    … …  
    482482{
    483483        /* FIXME: Implement your code here */
    484         p->rng_fault_state = True;
     484        p->;
    485485        return WERR_NOT_SUPPORTED;
    486486}
    … …  
    489489{
    490490        /* FIXME: Implement your code here */
    491         p->rng_fault_state = True;
     491        p->;
    492492        return WERR_NOT_SUPPORTED;
    493493}
    … …  
    496496{
    497497        /* FIXME: Implement your code here */
    498         p->rng_fault_state = True;
     498        p->;
    499499        return WERR_NOT_SUPPORTED;
    500500}
    … …  
    503503{
    504504        /* FIXME: Implement your code here */
    505         p->rng_fault_state = True;
     505        p->;
    506506        return WERR_NOT_SUPPORTED;
    507507}
    … …  
    510510{
    511511        /* FIXME: Implement your code here */
    512         p->rng_fault_state = True;
     512        p->;
    513513        return WERR_NOT_SUPPORTED;
    514514}
    … …  
    517517{
    518518        /* FIXME: Implement your code here */
    519         p->rng_fault_state = True;
     519        p->;
    520520        return WERR_NOT_SUPPORTED;
    521521}
    … …  
    524524{
    525525        /* FIXME: Implement your code here */
    526         p->rng_fault_state = True;
     526        p->;
    527527        return WERR_NOT_SUPPORTED;
    528528}
    … …  
    531531{
    532532        /* FIXME: Implement your code here */
    533         p->rng_fault_state = True;
    534         return WERR_NOT_SUPPORTED;
    535 }
     533        p->;
     534        return WERR_NOT_SUPPORTED;
     535}

  • trunk/server/source3/rpc_server/dssetup/srv_dssetup_nt.c

    r918 r920  
    131131                                        struct dssetup_DsRoleDnsNameToFlatName *r)
    132132{
    133         p->rng_fault_state = true;
     133        p->;
    134134        return WERR_NOT_SUPPORTED;
    135135}
    … …  
    141141                             struct dssetup_DsRoleDcAsDc *r)
    142142{
    143         p->rng_fault_state = true;
     143        p->;
    144144        return WERR_NOT_SUPPORTED;
    145145}
    … …  
    151151                                  struct dssetup_DsRoleDcAsReplica *r)
    152152{
    153         p->rng_fault_state = true;
     153        p->;
    154154        return WERR_NOT_SUPPORTED;
    155155}
    … …  
    161161                               struct dssetup_DsRoleDemoteDc *r)
    162162{
    163         p->rng_fault_state = true;
     163        p->;
    164164        return WERR_NOT_SUPPORTED;
    165165}
    … …  
    171171                                             struct dssetup_DsRoleGetDcOperationProgress *r)
    172172{
    173         p->rng_fault_state = true;
     173        p->;
    174174        return WERR_NOT_SUPPORTED;
    175175}
    … …  
    181181                                            struct dssetup_DsRoleGetDcOperationResults *r)
    182182{
    183         p->rng_fault_state = true;
     183        p->;
    184184        return WERR_NOT_SUPPORTED;
    185185}
    … …  
    191191                             struct dssetup_DsRoleCancel *r)
    192192{
    193         p->rng_fault_state = true;
     193        p->;
    194194        return WERR_NOT_SUPPORTED;
    195195}
    … …  
    201201                                                struct dssetup_DsRoleServerSaveStateForUpgrade *r)
    202202{
    203         p->rng_fault_state = true;
     203        p->;
    204204        return WERR_NOT_SUPPORTED;
    205205}
    … …  
    211211                                             struct dssetup_DsRoleUpgradeDownlevelServer *r)
    212212{
    213         p->rng_fault_state = true;
     213        p->;
    214214        return WERR_NOT_SUPPORTED;
    215215}
    … …  
    221221                                                  struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
    222222{
    223         p->rng_fault_state = true;
    224         return WERR_NOT_SUPPORTED;
    225 }
     223        p->;
     224        return WERR_NOT_SUPPORTED;
     225}

  • trunk/server/source3/rpc_server/echo/srv_echo_nt.c

    r918 r920  
    8888void _echo_TestCall(struct pipes_struct *p, struct echo_TestCall *r)
    8989{
    90         p->rng_fault_state = True;
     90        p->;
    9191        return;
    9292}
    … …  
    9494NTSTATUS _echo_TestCall2(struct pipes_struct *p, struct echo_TestCall2 *r)
    9595{
    96         p->rng_fault_state = True;
     96        p->;
    9797        return NT_STATUS_OK;
    9898}
    … …  
    106106void _echo_TestEnum(struct pipes_struct *p, struct echo_TestEnum *r)
    107107{
    108         p->rng_fault_state = True;
     108        p->;
    109109        return;
    110110}
    … …  
    112112void _echo_TestSurrounding(struct pipes_struct *p, struct echo_TestSurrounding *r)
    113113{
    114         p->rng_fault_state = True;
     114        p->;
    115115        return;
    116116}
    … …  
    118118uint16 _echo_TestDoublePointer(struct pipes_struct *p, struct echo_TestDoublePointer *r)
    119119{
    120         p->rng_fault_state = True;
     120        p->;
    121121        return 0;
    122122}

  • trunk/server/source3/rpc_server/epmapper/srv_epmapper.c

    r918 r920  
    298298        if (p->transport != NCALRPC ||
    299299            !is_priviledged_pipe(p->session_info)) {
     300
    300301                return EPMAPPER_STATUS_CANT_PERFORM_OP;
    301302        }
    … …  
    434435        if (p->transport != NCALRPC ||
    435436            !is_priviledged_pipe(p->session_info)) {
     437
    436438                return EPMAPPER_STATUS_CANT_PERFORM_OP;
    437439        }
    … …  
    10971099                      struct epm_InqObject *r)
    10981100{
    1099         p->rng_fault_state = true;
     1101        p->;
    11001102        return EPMAPPER_STATUS_CANT_PERFORM_OP;
    11011103}
    … …  
    11111113                       struct epm_MgmtDelete *r)
    11121114{
    1113         p->rng_fault_state = true;
     1115        p->;
    11141116        return EPMAPPER_STATUS_CANT_PERFORM_OP;
    11151117}
    … …  
    11221124                    struct epm_MapAuth *r)
    11231125{
    1124         p->rng_fault_state = true;
     1126        p->;
    11251127        return EPMAPPER_STATUS_CANT_PERFORM_OP;
    11261128}

  • trunk/server/source3/rpc_server/eventlog/srv_eventlog_nt.c

    r918 r920  
    696696NTSTATUS _eventlog_BackupEventLogW(struct pipes_struct *p, struct eventlog_BackupEventLogW *r)
    697697{
    698         p->rng_fault_state = True;
     698        p->;
    699699        return NT_STATUS_NOT_IMPLEMENTED;
    700700}
    … …  
    839839                                         struct eventlog_DeregisterEventSource *r)
    840840{
    841         p->rng_fault_state = True;
     841        p->;
    842842        return NT_STATUS_NOT_IMPLEMENTED;
    843843}
    … …  
    846846                                struct eventlog_ChangeNotify *r)
    847847{
    848         p->rng_fault_state = True;
     848        p->;
    849849        return NT_STATUS_NOT_IMPLEMENTED;
    850850}
    … …  
    853853                                        struct eventlog_RegisterEventSourceW *r)
    854854{
    855         p->rng_fault_state = True;
     855        p->;
    856856        return NT_STATUS_NOT_IMPLEMENTED;
    857857}
    … …  
    860860                                       struct eventlog_OpenBackupEventLogW *r)
    861861{
    862         p->rng_fault_state = True;
     862        p->;
    863863        return NT_STATUS_NOT_IMPLEMENTED;
    864864}
    … …  
    867867                                  struct eventlog_ClearEventLogA *r)
    868868{
    869         p->rng_fault_state = True;
     869        p->;
    870870        return NT_STATUS_NOT_IMPLEMENTED;
    871871}
    … …  
    874874                                   struct eventlog_BackupEventLogA *r)
    875875{
    876         p->rng_fault_state = True;
     876        p->;
    877877        return NT_STATUS_NOT_IMPLEMENTED;
    878878}
    … …  
    881881                                 struct eventlog_OpenEventLogA *r)
    882882{
    883         p->rng_fault_state = True;
     883        p->;
    884884        return NT_STATUS_NOT_IMPLEMENTED;
    885885}
    … …  
    888888                                        struct eventlog_RegisterEventSourceA *r)
    889889{
    890         p->rng_fault_state = True;
     890        p->;
    891891        return NT_STATUS_NOT_IMPLEMENTED;
    892892}
    … …  
    895895                                       struct eventlog_OpenBackupEventLogA *r)
    896896{
    897         p->rng_fault_state = True;
     897        p->;
    898898        return NT_STATUS_NOT_IMPLEMENTED;
    899899}
    … …  
    902902                                 struct eventlog_ReadEventLogA *r)
    903903{
    904         p->rng_fault_state = True;
     904        p->;
    905905        return NT_STATUS_NOT_IMPLEMENTED;
    906906}
    … …  
    909909                                struct eventlog_ReportEventA *r)
    910910{
    911         p->rng_fault_state = True;
     911        p->;
    912912        return NT_STATUS_NOT_IMPLEMENTED;
    913913}
    … …  
    916916                                      struct eventlog_RegisterClusterSvc *r)
    917917{
    918         p->rng_fault_state = True;
     918        p->;
    919919        return NT_STATUS_NOT_IMPLEMENTED;
    920920}
    … …  
    923923                                        struct eventlog_DeregisterClusterSvc *r)
    924924{
    925         p->rng_fault_state = True;
     925        p->;
    926926        return NT_STATUS_NOT_IMPLEMENTED;
    927927}
    … …  
    930930                                      struct eventlog_WriteClusterEvents *r)
    931931{
    932         p->rng_fault_state = True;
     932        p->;
    933933        return NT_STATUS_NOT_IMPLEMENTED;
    934934}
    … …  
    937937                                         struct eventlog_ReportEventAndSourceW *r)
    938938{
    939         p->rng_fault_state = True;
    940         return NT_STATUS_NOT_IMPLEMENTED;
    941 }
     939        p->;
     940        return NT_STATUS_NOT_IMPLEMENTED;
     941}

  • trunk/server/source3/rpc_server/lsa/srv_lsa_nt.c

    r918 r920  
    818818
    819819        if ((pdb_capabilities() & PDB_CAP_ADS) == 0) {
    820                 p->rng_fault_state = True;
     820                p->;
    821821                return NT_STATUS_NOT_IMPLEMENTED;
    822822        }
    … …  
    32113211NTSTATUS _lsa_SetSecObj(struct pipes_struct *p, struct lsa_SetSecObj *r)
    32123212{
    3213         p->rng_fault_state = True;
     3213        p->;
    32143214        return NT_STATUS_NOT_IMPLEMENTED;
    32153215}
    … …  
    32183218                             struct lsa_ChangePassword *r)
    32193219{
    3220         p->rng_fault_state = True;
     3220        p->;
    32213221        return NT_STATUS_NOT_IMPLEMENTED;
    32223222}
    … …  
    32243224NTSTATUS _lsa_SetInfoPolicy(struct pipes_struct *p, struct lsa_SetInfoPolicy *r)
    32253225{
    3226         p->rng_fault_state = True;
     3226        p->;
    32273227        return NT_STATUS_NOT_IMPLEMENTED;
    32283228}
    … …  
    32303230NTSTATUS _lsa_ClearAuditLog(struct pipes_struct *p, struct lsa_ClearAuditLog *r)
    32313231{
    3232         p->rng_fault_state = True;
     3232        p->;
    32333233        return NT_STATUS_NOT_IMPLEMENTED;
    32343234}
    … …  
    32373237                                  struct lsa_GetQuotasForAccount *r)
    32383238{
    3239         p->rng_fault_state = True;
     3239        p->;
    32403240        return NT_STATUS_NOT_IMPLEMENTED;
    32413241}
    … …  
    32443244                                  struct lsa_SetQuotasForAccount *r)
    32453245{
    3246         p->rng_fault_state = True;
     3246        p->;
    32473247        return NT_STATUS_NOT_IMPLEMENTED;
    32483248}
    … …  
    32513251                                          struct lsa_SetInformationTrustedDomain *r)
    32523252{
    3253         p->rng_fault_state = True;
     3253        p->;
    32543254        return NT_STATUS_NOT_IMPLEMENTED;
    32553255}
    … …  
    32573257NTSTATUS _lsa_QuerySecret(struct pipes_struct *p, struct lsa_QuerySecret *r)
    32583258{
    3259         p->rng_fault_state = True;
     3259        p->;
    32603260        return NT_STATUS_NOT_IMPLEMENTED;
    32613261}
    … …  
    32643264                                   struct lsa_SetTrustedDomainInfo *r)
    32653265{
    3266         p->rng_fault_state = True;
     3266        p->;
    32673267        return NT_STATUS_NOT_IMPLEMENTED;
    32683268}
    … …  
    32713271                               struct lsa_StorePrivateData *r)
    32723272{
    3273         p->rng_fault_state = True;
     3273        p->;
    32743274        return NT_STATUS_NOT_IMPLEMENTED;
    32753275}
    … …  
    32783278                                  struct lsa_RetrievePrivateData *r)
    32793279{
    3280         p->rng_fault_state = True;
     3280        p->;
    32813281        return NT_STATUS_NOT_IMPLEMENTED;
    32823282}
    … …  
    32853285                             struct lsa_SetInfoPolicy2 *r)
    32863286{
    3287         p->rng_fault_state = True;
     3287        p->;
    32883288        return NT_STATUS_NOT_IMPLEMENTED;
    32893289}
    … …  
    32923292                                         struct lsa_SetTrustedDomainInfoByName *r)
    32933293{
    3294         p->rng_fault_state = True;
     3294        p->;
    32953295        return NT_STATUS_NOT_IMPLEMENTED;
    32963296}
    … …  
    33113311
    33123312        if (!(pdb_capabilities() & PDB_CAP_TRUSTED_DOMAINS_EX)) {
    3313                 p->rng_fault_state = True;
     3313                p->;
    33143314                return NT_STATUS_NOT_IMPLEMENTED;
    33153315        }
    … …  
    33803380                                           struct lsa_QueryDomainInformationPolicy *r)
    33813381{
    3382         p->rng_fault_state = True;
     3382        p->;
    33833383        return NT_STATUS_NOT_IMPLEMENTED;
    33843384}
    … …  
    33873387                                         struct lsa_SetDomainInformationPolicy *r)
    33883388{
    3389         p->rng_fault_state = True;
     3389        p->;
    33903390        return NT_STATUS_NOT_IMPLEMENTED;
    33913391}
    … …  
    33933393NTSTATUS _lsa_TestCall(struct pipes_struct *p, struct lsa_TestCall *r)
    33943394{
    3395         p->rng_fault_state = True;
     3395        p->;
    33963396        return NT_STATUS_NOT_IMPLEMENTED;
    33973397}
    … …  
    33993399NTSTATUS _lsa_CREDRWRITE(struct pipes_struct *p, struct lsa_CREDRWRITE *r)
    34003400{
    3401         p->rng_fault_state = True;
     3401        p->;
    34023402        return NT_STATUS_NOT_IMPLEMENTED;
    34033403}
    … …  
    34053405NTSTATUS _lsa_CREDRREAD(struct pipes_struct *p, struct lsa_CREDRREAD *r)
    34063406{
    3407         p->rng_fault_state = True;
     3407        p->;
    34083408        return NT_STATUS_NOT_IMPLEMENTED;
    34093409}
    … …  
    34113411NTSTATUS _lsa_CREDRENUMERATE(struct pipes_struct *p, struct lsa_CREDRENUMERATE *r)
    34123412{
    3413         p->rng_fault_state = True;
     3413        p->;
    34143414        return NT_STATUS_NOT_IMPLEMENTED;
    34153415}
    … …  
    34183418                                          struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
    34193419{
    3420         p->rng_fault_state = True;
     3420        p->;
    34213421        return NT_STATUS_NOT_IMPLEMENTED;
    34223422}
    … …  
    34253425                                         struct lsa_CREDRREADDOMAINCREDENTIALS *r)
    34263426{
    3427         p->rng_fault_state = True;
     3427        p->;
    34283428        return NT_STATUS_NOT_IMPLEMENTED;
    34293429}
    … …  
    34313431NTSTATUS _lsa_CREDRDELETE(struct pipes_struct *p, struct lsa_CREDRDELETE *r)
    34323432{
    3433         p->rng_fault_state = True;
     3433        p->;
    34343434        return NT_STATUS_NOT_IMPLEMENTED;
    34353435}
    … …  
    34383438                                 struct lsa_CREDRGETTARGETINFO *r)
    34393439{
    3440         p->rng_fault_state = True;
     3440        p->;
    34413441        return NT_STATUS_NOT_IMPLEMENTED;
    34423442}
    … …  
    34453445                                 struct lsa_CREDRPROFILELOADED *r)
    34463446{
    3447         p->rng_fault_state = True;
     3447        p->;
    34483448        return NT_STATUS_NOT_IMPLEMENTED;
    34493449}
    … …  
    34523452                                   struct lsa_CREDRGETSESSIONTYPES *r)
    34533453{
    3454         p->rng_fault_state = True;
     3454        p->;
    34553455        return NT_STATUS_NOT_IMPLEMENTED;
    34563456}
    … …  
    34593459                                     struct lsa_LSARREGISTERAUDITEVENT *r)
    34603460{
    3461         p->rng_fault_state = True;
     3461        p->;
    34623462        return NT_STATUS_NOT_IMPLEMENTED;
    34633463}
    … …  
    34663466                                struct lsa_LSARGENAUDITEVENT *r)
    34673467{
    3468         p->rng_fault_state = True;
     3468        p->;
    34693469        return NT_STATUS_NOT_IMPLEMENTED;
    34703470}
    … …  
    34733473                                       struct lsa_LSARUNREGISTERAUDITEVENT *r)
    34743474{
    3475         p->rng_fault_state = True;
     3475        p->;
    34763476        return NT_STATUS_NOT_IMPLEMENTED;
    34773477}
    … …  
    34803480                                              struct lsa_lsaRQueryForestTrustInformation *r)
    34813481{
    3482         p->rng_fault_state = True;
     3482        p->;
    34833483        return NT_STATUS_NOT_IMPLEMENTED;
    34843484}
    … …  
    39933993                          struct lsa_CREDRRENAME *r)
    39943994{
    3995         p->rng_fault_state = True;
     3995        p->;
    39963996        return NT_STATUS_NOT_IMPLEMENTED;
    39973997}
    … …  
    40004000                                struct lsa_LSAROPENPOLICYSCE *r)
    40014001{
    4002         p->rng_fault_state = True;
     4002        p->;
    40034003        return NT_STATUS_NOT_IMPLEMENTED;
    40044004}
    … …  
    40074007                                                 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
    40084008{
    4009         p->rng_fault_state = True;
     4009        p->;
    40104010        return NT_STATUS_NOT_IMPLEMENTED;
    40114011}
    … …  
    40144014                                                   struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
    40154015{
    4016         p->rng_fault_state = True;
     4016        p->;
    40174017        return NT_STATUS_NOT_IMPLEMENTED;
    40184018}
    … …  
    40214021                                         struct lsa_LSARADTREPORTSECURITYEVENT *r)
    40224022{
    4023         p->rng_fault_state = True;
     4023        p->;
    40244024        return NT_STATUS_NOT_IMPLEMENTED;
    40254025}

  • trunk/server/source3/rpc_server/netlogon/srv_netlog_nt.c

    r916 r920  
    15091509        {
    15101510                const char *wksname = nt_workstation;
     1511
    15111512
    15121513                status = make_auth_context_fixed(talloc_tos(), &auth_context,
    … …  
    15331534                        status = NT_STATUS_NO_MEMORY;
    15341535                }
     1536
     1537
     1538
     1539
     1540
     1541
     1542
     1543
    15351544                break;
    15361545        }
    … …  
    16371646                break;
    16381647        case 6:
     1648
     1649
     1650
     1651
     1652
     1653
     1654
     1655
    16391656                status = serverinfo_to_SamInfo6(server_info, pipe_session_key, 16,
    16401657                                                r->out.validation->sam6);
    … …  
    17881805                           struct netr_LogonUasLogon *r)
    17891806{
    1790         p->rng_fault_state = true;
     1807        p->;
    17911808        return WERR_NOT_SUPPORTED;
    17921809}
    … …  
    17981815                            struct netr_LogonUasLogoff *r)
    17991816{
    1800         p->rng_fault_state = true;
     1817        p->;
    18011818        return WERR_NOT_SUPPORTED;
    18021819}
    … …  
    18081825                              struct netr_DatabaseDeltas *r)
    18091826{
    1810         p->rng_fault_state = true;
     1827        p->;
    18111828        return NT_STATUS_NOT_IMPLEMENTED;
    18121829}
    … …  
    18181835                            struct netr_DatabaseSync *r)
    18191836{
    1820         p->rng_fault_state = true;
     1837        p->;
    18211838        return NT_STATUS_NOT_IMPLEMENTED;
    18221839}
    … …  
    18281845                             struct netr_AccountDeltas *r)
    18291846{
    1830         p->rng_fault_state = true;
     1847        p->;
    18311848        return NT_STATUS_NOT_IMPLEMENTED;
    18321849}
    … …  
    18381855                           struct netr_AccountSync *r)
    18391856{
    1840         p->rng_fault_state = true;
     1857        p->;
    18411858        return NT_STATUS_NOT_IMPLEMENTED;
    18421859}
    … …  
    19791996                             struct netr_DatabaseSync2 *r)
    19801997{
    1981         p->rng_fault_state = true;
     1998        p->;
    19821999        return NT_STATUS_NOT_IMPLEMENTED;
    19832000}
    … …  
    19892006                            struct netr_DatabaseRedo *r)
    19902007{
    1991         p->rng_fault_state = true;
     2008        p->;
    19922009        return NT_STATUS_NOT_IMPLEMENTED;
    19932010}
    … …  
    19992016                          struct netr_DsRGetDCName *r)
    20002017{
    2001         p->rng_fault_state = true;
     2018        p->;
    20022019        return WERR_NOT_SUPPORTED;
    20032020}
    … …  
    20182035                                     struct netr_NETRLOGONSETSERVICEBITS *r)
    20192036{
    2020         p->rng_fault_state = true;
     2037        p->;
    20212038        return WERR_NOT_SUPPORTED;
    20222039}
    … …  
    20282045                              struct netr_LogonGetTrustRid *r)
    20292046{
    2030         p->rng_fault_state = true;
     2047        p->;
    20312048        return WERR_NOT_SUPPORTED;
    20322049}
    … …  
    20382055                                          struct netr_NETRLOGONCOMPUTESERVERDIGEST *r)
    20392056{
    2040         p->rng_fault_state = true;
     2057        p->;
    20412058        return WERR_NOT_SUPPORTED;
    20422059}
    … …  
    20482065                                          struct netr_NETRLOGONCOMPUTECLIENTDIGEST *r)
    20492066{
    2050         p->rng_fault_state = true;
     2067        p->;
    20512068        return WERR_NOT_SUPPORTED;
    20522069}
    … …  
    20582075                            struct netr_DsRGetDCNameEx *r)
    20592076{
    2060         p->rng_fault_state = true;
     2077        p->;
    20612078        return WERR_NOT_SUPPORTED;
    20622079}
    … …  
    20682085                            struct netr_DsRGetSiteName *r)
    20692086{
    2070         p->rng_fault_state = true;
     2087        p->;
    20712088        return WERR_NOT_SUPPORTED;
    20722089}
    … …  
    20782095                                  struct netr_LogonGetDomainInfo *r)
    20792096{
    2080         p->rng_fault_state = true;
     2097        p->;
    20812098        return NT_STATUS_NOT_IMPLEMENTED;
    20822099}
    … …  
    20882105                               struct netr_ServerPasswordGet *r)
    20892106{
    2090         p->rng_fault_state = true;
     2107        p->;
    20912108        return WERR_NOT_SUPPORTED;
    20922109}
    … …  
    20982115                                struct netr_NETRLOGONSENDTOSAM *r)
    20992116{
    2100         p->rng_fault_state = true;
     2117        p->;
    21012118        return WERR_NOT_SUPPORTED;
    21022119}
    … …  
    21082125                                    struct netr_DsRAddressToSitenamesW *r)
    21092126{
    2110         p->rng_fault_state = true;
     2127        p->;
    21112128        return WERR_NOT_SUPPORTED;
    21122129}
    … …  
    21182135                             struct netr_DsRGetDCNameEx2 *r)
    21192136{
    2120         p->rng_fault_state = true;
     2137        p->;
    21212138        return WERR_NOT_SUPPORTED;
    21222139}
    … …  
    21282145                                                 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *r)
    21292146{
    2130         p->rng_fault_state = true;
     2147        p->;
    21312148        return WERR_NOT_SUPPORTED;
    21322149}
    … …  
    21382155                                           struct netr_NetrEnumerateTrustedDomainsEx *r)
    21392156{
    2140         p->rng_fault_state = true;
     2157        p->;
    21412158        return WERR_NOT_SUPPORTED;
    21422159}
    … …  
    21482165                                      struct netr_DsRAddressToSitenamesExW *r)
    21492166{
    2150         p->rng_fault_state = true;
     2167        p->;
    21512168        return WERR_NOT_SUPPORTED;
    21522169}
    … …  
    21582175                                   struct netr_DsrGetDcSiteCoverageW *r)
    21592176{
    2160         p->rng_fault_state = true;
     2177        p->;
    21612178        return WERR_NOT_SUPPORTED;
    21622179}
    … …  
    21682185                                      struct netr_DsrEnumerateDomainTrusts *r)
    21692186{
    2170         p->rng_fault_state = true;
     2187        p->;
    21712188        return WERR_NOT_SUPPORTED;
    21722189}
    … …  
    21782195                                         struct netr_DsrDeregisterDNSHostRecords *r)
    21792196{
    2180         p->rng_fault_state = true;
     2197        p->;
    21812198        return WERR_NOT_SUPPORTED;
    21822199}
    … …  
    21882205                                       struct netr_ServerTrustPasswordsGet *r)
    21892206{
    2190         p->rng_fault_state = true;
     2207        p->;
    21912208        return NT_STATUS_NOT_IMPLEMENTED;
    21922209}
    … …  
    21982215                                          struct netr_DsRGetForestTrustInformation *r)
    21992216{
    2200         p->rng_fault_state = true;
     2217        p->;
    22012218        return WERR_NOT_SUPPORTED;
    22022219}
    … …  
    22722289        /* TODO: check server name */
    22732290
    2274         status = schannel_check_creds_state(p->mem_ctx, lp_private_dir(),
    2275                                             r->in.computer_name,
    2276                                             r->in.credential,
    2277                                             r->out.return_authenticator,
    2278                                             &creds);
     2291        become_root();
     2292        status = netr_creds_server_step_check(p, p->mem_ctx,
     2293                                              r->in.computer_name,
     2294                                              r->in.credential,
     2295                                              r->out.return_authenticator,
     2296                                              &creds);
     2297        unbecome_root();
    22792298        if (!NT_STATUS_IS_OK(status)) {
    22802299                return status;
    … …  
    23722391        /* TODO: check server name */
    23732392
    2374         status = schannel_check_creds_state(p->mem_ctx, lp_private_dir(),
    2375                                             r->in.computer_name,
    2376                                             r->in.credential,
    2377                                             r->out.return_authenticator,
    2378                                             &creds);
     2393        become_root();
     2394        status = netr_creds_server_step_check(p, p->mem_ctx,
     2395                                              r->in.computer_name,
     2396                                              r->in.credential,
     2397                                              r->out.return_authenticator,
     2398                                              &creds);
     2399        unbecome_root();
    23792400        if (!NT_STATUS_IS_OK(status)) {
    23802401                return status;
    … …  
    24772498                        struct netr_Unused47 *r)
    24782499{
    2479         p->rng_fault_state = true;
     2500        p->;
    24802501        return NT_STATUS_NOT_IMPLEMENTED;
    24812502}
    … …  
    24872508                                                 struct netr_DsrUpdateReadOnlyServerDnsRecords *r)
    24882509{
    2489         p->rng_fault_state = true;
     2510        p->;
    24902511        return NT_STATUS_NOT_IMPLEMENTED;
    24912512}

  • trunk/server/source3/rpc_server/ntsvcs/srv_ntsvcs_nt.c

    r918 r920  
    228228                       struct PNP_Disconnect *r)
    229229{
    230         p->rng_fault_state = true;
     230        p->;
    231231        return WERR_NOT_SUPPORTED;
    232232}
    … …  
    238238                    struct PNP_Connect *r)
    239239{
    240         p->rng_fault_state = true;
     240        p->;
    241241        return WERR_NOT_SUPPORTED;
    242242}
    … …  
    248248                           struct PNP_GetGlobalState *r)
    249249{
    250         p->rng_fault_state = true;
     250        p->;
    251251        return WERR_NOT_SUPPORTED;
    252252}
    … …  
    258258                          struct PNP_InitDetection *r)
    259259{
    260         p->rng_fault_state = true;
     260        p->;
    261261        return WERR_NOT_SUPPORTED;
    262262}
    … …  
    268268                        struct PNP_ReportLogOn *r)
    269269{
    270         p->rng_fault_state = true;
     270        p->;
    271271        return WERR_NOT_SUPPORTED;
    272272}
    … …  
    278278                                  struct PNP_GetRootDeviceInstance *r)
    279279{
    280         p->rng_fault_state = true;
     280        p->;
    281281        return WERR_NOT_SUPPORTED;
    282282}
    … …  
    288288                                     struct PNP_GetRelatedDeviceInstance *r)
    289289{
    290         p->rng_fault_state = true;
     290        p->;
    291291        return WERR_NOT_SUPPORTED;
    292292}
    … …  
    298298                             struct PNP_EnumerateSubKeys *r)
    299299{
    300         p->rng_fault_state = true;
     300        p->;
    301301        return WERR_NOT_SUPPORTED;
    302302}
    … …  
    308308                     struct PNP_GetDepth *r)
    309309{
    310         p->rng_fault_state = true;
     310        p->;
    311311        return WERR_NOT_SUPPORTED;
    312312}
    … …  
    318318                             struct PNP_SetDeviceRegProp *r)
    319319{
    320         p->rng_fault_state = true;
     320        p->;
    321321        return WERR_NOT_SUPPORTED;
    322322}
    … …  
    328328                             struct PNP_GetClassInstance *r)
    329329{
    330         p->rng_fault_state = true;
     330        p->;
    331331        return WERR_NOT_SUPPORTED;
    332332}
    … …  
    338338                      struct PNP_CreateKey *r)
    339339{
    340         p->rng_fault_state = true;
     340        p->;
    341341        return WERR_NOT_SUPPORTED;
    342342}
    … …  
    348348                              struct PNP_DeleteRegistryKey *r)
    349349{
    350         p->rng_fault_state = true;
     350        p->;
    351351        return WERR_NOT_SUPPORTED;
    352352}
    … …  
    358358                          struct PNP_GetClassCount *r)
    359359{
    360         p->rng_fault_state = true;
     360        p->;
    361361        return WERR_NOT_SUPPORTED;
    362362}
    … …  
    368368                         struct PNP_GetClassName *r)
    369369{
    370         p->rng_fault_state = true;
     370        p->;
    371371        return WERR_NOT_SUPPORTED;
    372372}
    … …  
    378378                           struct PNP_DeleteClassKey *r)
    379379{
    380         p->rng_fault_state = true;
     380        p->;
    381381        return WERR_NOT_SUPPORTED;
    382382}
    … …  
    388388                                    struct PNP_GetInterfaceDeviceAlias *r)
    389389{
    390         p->rng_fault_state = true;
     390        p->;
    391391        return WERR_NOT_SUPPORTED;
    392392}
    … …  
    398398                                   struct PNP_GetInterfaceDeviceList *r)
    399399{
    400         p->rng_fault_state = true;
     400        p->;
    401401        return WERR_NOT_SUPPORTED;
    402402}
    … …  
    408408                                       struct PNP_GetInterfaceDeviceListSize *r)
    409409{
    410         p->rng_fault_state = true;
     410        p->;
    411411        return WERR_NOT_SUPPORTED;
    412412}
    … …  
    418418                                           struct PNP_RegisterDeviceClassAssociation *r)
    419419{
    420         p->rng_fault_state = true;
     420        p->;
    421421        return WERR_NOT_SUPPORTED;
    422422}
    … …  
    428428                                             struct PNP_UnregisterDeviceClassAssociation *r)
    429429{
    430         p->rng_fault_state = true;
     430        p->;
    431431        return WERR_NOT_SUPPORTED;
    432432}
    … …  
    438438                            struct PNP_GetClassRegProp *r)
    439439{
    440         p->rng_fault_state = true;
     440        p->;
    441441        return WERR_NOT_SUPPORTED;
    442442}
    … …  
    448448                            struct PNP_SetClassRegProp *r)
    449449{
    450         p->rng_fault_state = true;
     450        p->;
    451451        return WERR_NOT_SUPPORTED;
    452452}
    … …  
    458458                          struct PNP_CreateDevInst *r)
    459459{
    460         p->rng_fault_state = true;
     460        p->;
    461461        return WERR_NOT_SUPPORTED;
    462462}
    … …  
    468468                                 struct PNP_DeviceInstanceAction *r)
    469469{
    470         p->rng_fault_state = true;
     470        p->;
    471471        return WERR_NOT_SUPPORTED;
    472472}
    … …  
    478478                            struct PNP_GetDeviceStatus *r)
    479479{
    480         p->rng_fault_state = true;
     480        p->;
    481481        return WERR_NOT_SUPPORTED;
    482482}
    … …  
    488488                             struct PNP_SetDeviceProblem *r)
    489489{
    490         p->rng_fault_state = true;
     490        p->;
    491491        return WERR_NOT_SUPPORTED;
    492492}
    … …  
    498498                           struct PNP_DisableDevInst *r)
    499499{
    500         p->rng_fault_state = true;
     500        p->;
    501501        return WERR_NOT_SUPPORTED;
    502502}
    … …  
    508508                             struct PNP_UninstallDevInst *r)
    509509{
    510         p->rng_fault_state = true;
     510        p->;
    511511        return WERR_NOT_SUPPORTED;
    512512}
    … …  
    518518                  struct PNP_AddID *r)
    519519{
    520         p->rng_fault_state = true;
     520        p->;
    521521        return WERR_NOT_SUPPORTED;
    522522}
    … …  
    528528                           struct PNP_RegisterDriver *r)
    529529{
    530         p->rng_fault_state = true;
     530        p->;
    531531        return WERR_NOT_SUPPORTED;
    532532}
    … …  
    538538                        struct PNP_QueryRemove *r)
    539539{
    540         p->rng_fault_state = true;
     540        p->;
    541541        return WERR_NOT_SUPPORTED;
    542542}
    … …  
    548548                               struct PNP_RequestDeviceEject *r)
    549549{
    550         p->rng_fault_state = true;
     550        p->;
    551551        return WERR_NOT_SUPPORTED;
    552552}
    … …  
    558558                                 struct PNP_IsDockStationPresent *r)
    559559{
    560         p->rng_fault_state = true;
     560        p->;
    561561        return WERR_NOT_SUPPORTED;
    562562}
    … …  
    568568                           struct PNP_RequestEjectPC *r)
    569569{
    570         p->rng_fault_state = true;
     570        p->;
    571571        return WERR_NOT_SUPPORTED;
    572572}
    … …  
    578578                            struct PNP_AddEmptyLogConf *r)
    579579{
    580         p->rng_fault_state = true;
     580        p->;
    581581        return WERR_NOT_SUPPORTED;
    582582}
    … …  
    588588                        struct PNP_FreeLogConf *r)
    589589{
    590         p->rng_fault_state = true;
     590        p->;
    591591        return WERR_NOT_SUPPORTED;
    592592}
    … …  
    598598                            struct PNP_GetFirstLogConf *r)
    599599{
    600         p->rng_fault_state = true;
     600        p->;
    601601        return WERR_NOT_SUPPORTED;
    602602}
    … …  
    608608                           struct PNP_GetNextLogConf *r)
    609609{
    610         p->rng_fault_state = true;
     610        p->;
    611611        return WERR_NOT_SUPPORTED;
    612612}
    … …  
    618618                               struct PNP_GetLogConfPriority *r)
    619619{
    620         p->rng_fault_state = true;
     620        p->;
    621621        return WERR_NOT_SUPPORTED;
    622622}
    … …  
    628628                      struct PNP_AddResDes *r)
    629629{
    630         p->rng_fault_state = true;
     630        p->;
    631631        return WERR_NOT_SUPPORTED;
    632632}
    … …  
    638638                       struct PNP_FreeResDes *r)
    639639{
    640         p->rng_fault_state = true;
     640        p->;
    641641        return WERR_NOT_SUPPORTED;
    642642}
    … …  
    648648                          struct PNP_GetNextResDes *r)
    649649{
    650         p->rng_fault_state = true;
     650        p->;
    651651        return WERR_NOT_SUPPORTED;
    652652}
    … …  
    658658                          struct PNP_GetResDesData *r)
    659659{
    660         p->rng_fault_state = true;
     660        p->;
    661661        return WERR_NOT_SUPPORTED;
    662662}
    … …  
    668668                              struct PNP_GetResDesDataSize *r)
    669669{
    670         p->rng_fault_state = true;
     670        p->;
    671671        return WERR_NOT_SUPPORTED;
    672672}
    … …  
    678678                         struct PNP_ModifyResDes *r)
    679679{
    680         p->rng_fault_state = true;
     680        p->;
    681681        return WERR_NOT_SUPPORTED;
    682682}
    … …  
    688688                                struct PNP_DetectResourceLimit *r)
    689689{
    690         p->rng_fault_state = true;
     690        p->;
    691691        return WERR_NOT_SUPPORTED;
    692692}
    … …  
    698698                             struct PNP_QueryResConfList *r)
    699699{
    700         p->rng_fault_state = true;
     700        p->;
    701701        return WERR_NOT_SUPPORTED;
    702702}
    … …  
    708708                      struct PNP_SetHwProf *r)
    709709{
    710         p->rng_fault_state = true;
     710        p->;
    711711        return WERR_NOT_SUPPORTED;
    712712}
    … …  
    718718                                    struct PNP_QueryArbitratorFreeData *r)
    719719{
    720         p->rng_fault_state = true;
     720        p->;
    721721        return WERR_NOT_SUPPORTED;
    722722}
    … …  
    728728                                    struct PNP_QueryArbitratorFreeSize *r)
    729729{
    730         p->rng_fault_state = true;
     730        p->;
    731731        return WERR_NOT_SUPPORTED;
    732732}
    … …  
    738738                         struct PNP_RunDetection *r)
    739739{
    740         p->rng_fault_state = true;
     740        p->;
    741741        return WERR_NOT_SUPPORTED;
    742742}
    … …  
    748748                                 struct PNP_RegisterNotification *r)
    749749{
    750         p->rng_fault_state = true;
     750        p->;
    751751        return WERR_NOT_SUPPORTED;
    752752}
    … …  
    758758                                   struct PNP_UnregisterNotification *r)
    759759{
    760         p->rng_fault_state = true;
     760        p->;
    761761        return WERR_NOT_SUPPORTED;
    762762}
    … …  
    768768                             struct PNP_GetCustomDevProp *r)
    769769{
    770         p->rng_fault_state = true;
     770        p->;
    771771        return WERR_NOT_SUPPORTED;
    772772}
    … …  
    778778                               struct PNP_GetVersionInternal *r)
    779779{
    780         p->rng_fault_state = true;
     780        p->;
    781781        return WERR_NOT_SUPPORTED;
    782782}
    … …  
    788788                                 struct PNP_GetBlockedDriverInfo *r)
    789789{
    790         p->rng_fault_state = true;
     790        p->;
    791791        return WERR_NOT_SUPPORTED;
    792792}
    … …  
    798798                                            struct PNP_GetServerSideDeviceInstallFlags *r)
    799799{
    800         p->rng_fault_state = true;
    801         return WERR_NOT_SUPPORTED;
    802 }
     800        p->;
     801        return WERR_NOT_SUPPORTED;
     802}

  • trunk/server/source3/rpc_server/rpc_handles.c

    r918 r920  
    243243        dump_data(4, (uint8_t *)hnd, sizeof(*hnd));
    244244
    245         p->bad_handle_fault_state = true;
     245        p->;
    246246
    247247        return NULL;

  • trunk/server/source3/rpc_server/rpc_ncacn_np.c

    r918 r920  
    172172        p->syntax = *syntax;
    173173        p->transport = NCALRPC;
     174
    174175
    175176        DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
    … …  
    217218
    218219        if (p->fault_state) {
    219                 p->fault_state = false;
     220                NTSTATUS status;
     221
     222                status = NT_STATUS(p->fault_state);
     223                p->fault_state = 0;
    220224                data_blob_free(&p->out_data.rdata);
    221225                talloc_free_children(p->mem_ctx);
    222                 return NT_STATUS_RPC_CALL_FAILED;
    223         }
    224 
    225         if (p->bad_handle_fault_state) {
    226                 p->bad_handle_fault_state = false;
    227                 data_blob_free(&p->out_data.rdata);
    228                 talloc_free_children(p->mem_ctx);
    229                 return NT_STATUS_RPC_SS_CONTEXT_MISMATCH;
    230         }
    231 
    232         if (p->rng_fault_state) {
    233                 p->rng_fault_state = false;
    234                 data_blob_free(&p->out_data.rdata);
    235                 talloc_free_children(p->mem_ctx);
    236                 return NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE;
     226                return status;
    237227        }
    238228
    … …  
    792782        result->auth->auth_type = DCERPC_AUTH_TYPE_NONE;
    793783        result->auth->auth_level = DCERPC_AUTH_LEVEL_NONE;
     784
    794785
    795786        status = rpccli_anon_bind_data(result, &auth);

  • trunk/server/source3/rpc_server/rpc_server.c

    r745 r920  
    103103        p->transport = transport;
    104104        p->ncalrpc_as_system = ncalrpc_as_system;
     105
    105106
    106107        p->mem_ctx = talloc_named(p, 0, "pipe %s %p", pipe_name, p);
    … …  
    661662        if (ret == -1) {
    662663                DEBUG(2, ("Writev failed!\n"));
     664
     665
     666
     667
     668
     669
    663670                goto fail;
    664671        }
    … …  
    13921399        }
    13931400
     1401
     1402
     1403
     1404
     1405
     1406
    13941407        /* clear out any data that may have been left around */
    13951408        ncacn_conn->count = 0;

  • trunk/server/source3/rpc_server/samr/srv_samr_nt.c

    r862 r920  
    66296629        struct samr_PwInfo dom_pw_info;
    66306630
     6631
     6632
     6633
     6634
     6635
    66316636        if (r->in.level < 1 || r->in.level > 3) {
    66326637                return NT_STATUS_INVALID_INFO_CLASS;
    … …  
    66836688                        struct samr_Shutdown *r)
    66846689{
    6685         p->rng_fault_state = true;
     6690        p->;
    66866691        return NT_STATUS_NOT_IMPLEMENTED;
    66876692}
    … …  
    66936698                                          struct samr_SetMemberAttributesOfGroup *r)
    66946699{
    6695         p->rng_fault_state = true;
     6700        p->;
    66966701        return NT_STATUS_NOT_IMPLEMENTED;
    66976702}
    … …  
    67036708                                          struct samr_TestPrivateFunctionsDomain *r)
    67046709{
     6710
    67056711        return NT_STATUS_NOT_IMPLEMENTED;
    67066712}
    … …  
    67126718                                        struct samr_TestPrivateFunctionsUser *r)
    67136719{
     6720
    67146721        return NT_STATUS_NOT_IMPLEMENTED;
    67156722}
    … …  
    67216728                                         struct samr_AddMultipleMembersToAlias *r)
    67226729{
    6723         p->rng_fault_state = true;
     6730        p->;
    67246731        return NT_STATUS_NOT_IMPLEMENTED;
    67256732}
    … …  
    67316738                                              struct samr_RemoveMultipleMembersFromAlias *r)
    67326739{
    6733         p->rng_fault_state = true;
     6740        p->;
    67346741        return NT_STATUS_NOT_IMPLEMENTED;
    67356742}
    … …  
    67416748                                     struct samr_SetBootKeyInformation *r)
    67426749{
    6743         p->rng_fault_state = true;
     6750        p->;
    67446751        return NT_STATUS_NOT_IMPLEMENTED;
    67456752}
    … …  
    67516758                                     struct samr_GetBootKeyInformation *r)
    67526759{
    6753         p->rng_fault_state = true;
     6760        p->;
    67546761        return NT_STATUS_NOT_IMPLEMENTED;
    67556762}
    … …  
    67616768                               struct samr_SetDsrmPassword *r)
    67626769{
    6763         p->rng_fault_state = true;
     6770        p->;
    67646771        return NT_STATUS_NOT_IMPLEMENTED;
    67656772}

  • trunk/server/source3/rpc_server/spoolss/srv_spoolss_nt.c

    r862 r920  
    24812481                "", /* domain */
    24822482                "", /* password */
    2483                 0, lp_client_signing());
     2483                0, );
    24842484
    24852485        if ( !NT_STATUS_IS_OK( ret ) ) {
    … …  
    1015710157                                 struct spoolss_GetPrinterDriver *r)
    1015810158{
    10159         p->rng_fault_state = true;
     10159        p->;
    1016010160        return WERR_NOT_SUPPORTED;
    1016110161}
    … …  
    1016810168                            struct spoolss_ReadPrinter *r)
    1016910169{
    10170         p->rng_fault_state = true;
     10170        p->;
    1017110171        return WERR_NOT_SUPPORTED;
    1017210172}
    … …  
    1017910179                                     struct spoolss_WaitForPrinterChange *r)
    1018010180{
    10181         p->rng_fault_state = true;
     10181        p->;
    1018210182        return WERR_NOT_SUPPORTED;
    1018310183}
    … …  
    1019010190                              struct spoolss_ConfigurePort *r)
    1019110191{
    10192         p->rng_fault_state = true;
     10192        p->;
    1019310193        return WERR_NOT_SUPPORTED;
    1019410194}
    … …  
    1020110201                           struct spoolss_DeletePort *r)
    1020210202{
    10203         p->rng_fault_state = true;
     10203        p->;
    1020410204        return WERR_NOT_SUPPORTED;
    1020510205}
    … …  
    1021210212                                struct spoolss_CreatePrinterIC *r)
    1021310213{
    10214         p->rng_fault_state = true;
     10214        p->;
    1021510215        return WERR_NOT_SUPPORTED;
    1021610216}
    … …  
    1022310223                                         struct spoolss_PlayGDIScriptOnPrinterIC *r)
    1022410224{
    10225         p->rng_fault_state = true;
     10225        p->;
    1022610226        return WERR_NOT_SUPPORTED;
    1022710227}
    … …  
    1023410234                                struct spoolss_DeletePrinterIC *r)
    1023510235{
    10236         p->rng_fault_state = true;
     10236        p->;
    1023710237        return WERR_NOT_SUPPORTED;
    1023810238}
    … …  
    1024510245                                     struct spoolss_AddPrinterConnection *r)
    1024610246{
    10247         p->rng_fault_state = true;
     10247        p->;
    1024810248        return WERR_NOT_SUPPORTED;
    1024910249}
    … …  
    1025610256                                        struct spoolss_DeletePrinterConnection *r)
    1025710257{
    10258         p->rng_fault_state = true;
     10258        p->;
    1025910259        return WERR_NOT_SUPPORTED;
    1026010260}
    … …  
    1026710267                                  struct spoolss_PrinterMessageBox *r)
    1026810268{
    10269         p->rng_fault_state = true;
     10269        p->;
    1027010270        return WERR_NOT_SUPPORTED;
    1027110271}
    … …  
    1027810278                           struct spoolss_AddMonitor *r)
    1027910279{
    10280         p->rng_fault_state = true;
     10280        p->;
    1028110281        return WERR_NOT_SUPPORTED;
    1028210282}
    … …  
    1028910289                              struct spoolss_DeleteMonitor *r)
    1029010290{
    10291         p->rng_fault_state = true;
     10291        p->;
    1029210292        return WERR_NOT_SUPPORTED;
    1029310293}
    … …  
    1030010300                                     struct spoolss_DeletePrintProcessor *r)
    1030110301{
    10302         p->rng_fault_state = true;
     10302        p->;
    1030310303        return WERR_NOT_SUPPORTED;
    1030410304}
    … …  
    1031110311                                 struct spoolss_AddPrintProvidor *r)
    1031210312{
    10313         p->rng_fault_state = true;
     10313        p->;
    1031410314        return WERR_NOT_SUPPORTED;
    1031510315}
    … …  
    1032210322                                    struct spoolss_DeletePrintProvidor *r)
    1032310323{
    10324         p->rng_fault_state = true;
     10324        p->;
    1032510325        return WERR_NOT_SUPPORTED;
    1032610326}
    … …  
    1033310333                                                   struct spoolss_FindFirstPrinterChangeNotification *r)
    1033410334{
    10335         p->rng_fault_state = true;
     10335        p->;
    1033610336        return WERR_NOT_SUPPORTED;
    1033710337}
    … …  
    1034410344                                                  struct spoolss_FindNextPrinterChangeNotification *r)
    1034510345{
    10346         p->rng_fault_state = true;
     10346        p->;
    1034710347        return WERR_NOT_SUPPORTED;
    1034810348}
    … …  
    1035510355                                                            struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
    1035610356{
    10357         p->rng_fault_state = true;
     10357        p->;
    1035810358        return WERR_NOT_SUPPORTED;
    1035910359}
    … …  
    1036610366                                 struct spoolss_ReplyOpenPrinter *r)
    1036710367{
    10368         p->rng_fault_state = true;
     10368        p->;
    1036910369        return WERR_NOT_SUPPORTED;
    1037010370}
    … …  
    1037710377                                   struct spoolss_RouterReplyPrinter *r)
    1037810378{
    10379         p->rng_fault_state = true;
     10379        p->;
    1038010380        return WERR_NOT_SUPPORTED;
    1038110381}
    … …  
    1038810388                                  struct spoolss_ReplyClosePrinter *r)
    1038910389{
    10390         p->rng_fault_state = true;
     10390        p->;
    1039110391        return WERR_NOT_SUPPORTED;
    1039210392}
    … …  
    1039910399                          struct spoolss_AddPortEx *r)
    1040010400{
    10401         p->rng_fault_state = true;
     10401        p->;
    1040210402        return WERR_NOT_SUPPORTED;
    1040310403}
    … …  
    1041010410                                                         struct spoolss_RouterFindFirstPrinterChangeNotification *r)
    1041110411{
    10412         p->rng_fault_state = true;
     10412        p->;
    1041310413        return WERR_NOT_SUPPORTED;
    1041410414}
    … …  
    1042110421                            struct spoolss_SpoolerInit *r)
    1042210422{
    10423         p->rng_fault_state = true;
     10423        p->;
    1042410424        return WERR_NOT_SUPPORTED;
    1042510425}
    … …  
    1043210432                               struct spoolss_ResetPrinterEx *r)
    1043310433{
    10434         p->rng_fault_state = true;
     10434        p->;
    1043510435        return WERR_NOT_SUPPORTED;
    1043610436}
    … …  
    1044310443                                     struct spoolss_RouterReplyPrinterEx *r)
    1044410444{
    10445         p->rng_fault_state = true;
     10445        p->;
    1044610446        return WERR_NOT_SUPPORTED;
    1044710447}
    … …  
    1045410454                   struct spoolss_44 *r)
    1045510455{
    10456         p->rng_fault_state = true;
     10456        p->;
    1045710457        return WERR_NOT_SUPPORTED;
    1045810458}
    … …  
    1046510465                        struct spoolss_SetPort *r)
    1046610466{
    10467         p->rng_fault_state = true;
     10467        p->;
    1046810468        return WERR_NOT_SUPPORTED;
    1046910469}
    … …  
    1047610476                   struct spoolss_4a *r)
    1047710477{
    10478         p->rng_fault_state = true;
     10478        p->;
    1047910479        return WERR_NOT_SUPPORTED;
    1048010480}
    … …  
    1048710487                   struct spoolss_4b *r)
    1048810488{
    10489         p->rng_fault_state = true;
     10489        p->;
    1049010490        return WERR_NOT_SUPPORTED;
    1049110491}
    … …  
    1049810498                   struct spoolss_4c *r)
    1049910499{
    10500         p->rng_fault_state = true;
     10500        p->;
    1050110501        return WERR_NOT_SUPPORTED;
    1050210502}
    … …  
    1050910509                   struct spoolss_53 *r)
    1051010510{
    10511         p->rng_fault_state = true;
     10511        p->;
    1051210512        return WERR_NOT_SUPPORTED;
    1051310513}
    … …  
    1052010520                                        struct spoolss_AddPerMachineConnection *r)
    1052110521{
    10522         p->rng_fault_state = true;
     10522        p->;
    1052310523        return WERR_NOT_SUPPORTED;
    1052410524}
    … …  
    1053110531                                           struct spoolss_DeletePerMachineConnection *r)
    1053210532{
    10533         p->rng_fault_state = true;
     10533        p->;
    1053410534        return WERR_NOT_SUPPORTED;
    1053510535}
    … …  
    1054210542                                          struct spoolss_EnumPerMachineConnections *r)
    1054310543{
    10544         p->rng_fault_state = true;
     10544        p->;
    1054510545        return WERR_NOT_SUPPORTED;
    1054610546}
    … …  
    1055310553                   struct spoolss_5a *r)
    1055410554{
    10555         p->rng_fault_state = true;
     10555        p->;
    1055610556        return WERR_NOT_SUPPORTED;
    1055710557}
    … …  
    1056410564                   struct spoolss_5b *r)
    1056510565{
    10566         p->rng_fault_state = true;
     10566        p->;
    1056710567        return WERR_NOT_SUPPORTED;
    1056810568}
    … …  
    1057510575                   struct spoolss_5c *r)
    1057610576{
    10577         p->rng_fault_state = true;
     10577        p->;
    1057810578        return WERR_NOT_SUPPORTED;
    1057910579}
    … …  
    1058610586                   struct spoolss_5d *r)
    1058710587{
    10588         p->rng_fault_state = true;
     10588        p->;
    1058910589        return WERR_NOT_SUPPORTED;
    1059010590}
    … …  
    1059710597                   struct spoolss_5e *r)
    1059810598{
    10599         p->rng_fault_state = true;
     10599        p->;
    1060010600        return WERR_NOT_SUPPORTED;
    1060110601}
    … …  
    1060810608                   struct spoolss_5f *r)
    1060910609{
    10610         p->rng_fault_state = true;
     10610        p->;
    1061110611        return WERR_NOT_SUPPORTED;
    1061210612}
    … …  
    1061910619                   struct spoolss_60 *r)
    1062010620{
    10621         p->rng_fault_state = true;
     10621        p->;
    1062210622        return WERR_NOT_SUPPORTED;
    1062310623}
    … …  
    1063010630                   struct spoolss_61 *r)
    1063110631{
    10632         p->rng_fault_state = true;
     10632        p->;
    1063310633        return WERR_NOT_SUPPORTED;
    1063410634}
    … …  
    1064110641                   struct spoolss_62 *r)
    1064210642{
    10643         p->rng_fault_state = true;
     10643        p->;
    1064410644        return WERR_NOT_SUPPORTED;
    1064510645}
    … …  
    1065210652                   struct spoolss_63 *r)
    1065310653{
    10654         p->rng_fault_state = true;
     10654        p->;
    1065510655        return WERR_NOT_SUPPORTED;
    1065610656}
    … …  
    1066310663                   struct spoolss_64 *r)
    1066410664{
    10665         p->rng_fault_state = true;
     10665        p->;
    1066610666        return WERR_NOT_SUPPORTED;
    1066710667}
    … …  
    1067410674                   struct spoolss_65 *r)
    1067510675{
    10676         p->rng_fault_state = true;
     10676        p->;
    1067710677        return WERR_NOT_SUPPORTED;
    1067810678}
    … …  
    1068510685                                      struct spoolss_GetCorePrinterDrivers *r)
    1068610686{
    10687         p->rng_fault_state = true;
     10687        p->;
    1068810688        return WERR_NOT_SUPPORTED;
    1068910689}
    … …  
    1069610696                   struct spoolss_67 *r)
    1069710697{
    10698         p->rng_fault_state = true;
     10698        p->;
    1069910699        return WERR_NOT_SUPPORTED;
    1070010700}
    … …  
    1070710707                                            struct spoolss_GetPrinterDriverPackagePath *r)
    1070810708{
    10709         p->rng_fault_state = true;
     10709        p->;
    1071010710        return WERR_NOT_SUPPORTED;
    1071110711}
    … …  
    1071810718                   struct spoolss_69 *r)
    1071910719{
    10720         p->rng_fault_state = true;
     10720        p->;
    1072110721        return WERR_NOT_SUPPORTED;
    1072210722}
    … …  
    1072910729                   struct spoolss_6a *r)
    1073010730{
    10731         p->rng_fault_state = true;
     10731        p->;
    1073210732        return WERR_NOT_SUPPORTED;
    1073310733}
    … …  
    1074010740                   struct spoolss_6b *r)
    1074110741{
    10742         p->rng_fault_state = true;
     10742        p->;
    1074310743        return WERR_NOT_SUPPORTED;
    1074410744}
    … …  
    1075110751                   struct spoolss_6c *r)
    1075210752{
    10753         p->rng_fault_state = true;
     10753        p->;
    1075410754        return WERR_NOT_SUPPORTED;
    1075510755}
    … …  
    1076210762                   struct spoolss_6d *r)
    1076310763{
    10764         p->rng_fault_state = true;
     10764        p->;
    1076510765        return WERR_NOT_SUPPORTED;
    1076610766}

  • trunk/server/source3/rpc_server/srv_pipe.c

    r918 r920  
    4343#include "ntdomain.h"
    4444#include "rpc_server/srv_pipe.h"
     45
     46
     47
     48
     49
     50
     51
    4552
    4653#undef DBGC_CLASS
    … …  
    203210         */
    204211        if (p->fault_state) {
    205                 setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
     212                setup_fault_pdu(p, NT_STATUS());
    206213                return true;
    207214        }
    … …  
    270277        p->out_data.current_pdu_sent = 0;
    271278
     279
    272280        TALLOC_FREE(p->auth.auth_ctx);
    273281        p->auth.auth_level = DCERPC_AUTH_LEVEL_NONE;
    274282        p->auth.auth_type = DCERPC_AUTH_TYPE_NONE;
    275283        p->pipe_bound = False;
     284
     285
     286
    276287
    277288        return True;
    … …  
    335346{
    336347        struct pipe_rpc_fns *context_fns;
     348
     349
    337350
    338351        DEBUG(3,("check_bind_req for %s\n",
    339                  get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     352                 get_pipe_name_from_syntax(talloc_tos(), abstract)));
     353
     354        ok = ndr_syntax_id_equal(transfer, &ndr_transfer_syntax);
     355        if (!ok) {
     356                DEBUG(1,("check_bind_req unknown transfer syntax for "
     357                         "%s context_id=%u\n",
     358                         get_pipe_name_from_syntax(talloc_tos(), abstract),
     359                         (unsigned)context_id));
     360                return false;
     361        }
     362
     363        for (context_fns = p->contexts;
     364             context_fns != NULL;
     365             context_fns = context_fns->next)
     366        {
     367                if (context_fns->context_id != context_id) {
     368                        continue;
     369                }
     370
     371                ok = ndr_syntax_id_equal(&context_fns->syntax,
     372                                         abstract);
     373                if (ok) {
     374                        return true;
     375                }
     376
     377                DEBUG(1,("check_bind_req: changing abstract syntax for "
     378                         "%s context_id=%u into %s not supported\n",
     379                         get_pipe_name_from_syntax(talloc_tos(), &context_fns->syntax),
     380                         (unsigned)context_id,
     381                         get_pipe_name_from_syntax(talloc_tos(), abstract)));
     382                return false;
     383        }
    340384
    341385        /* we have to check all now since win2k introduced a new UUID on the lsaprpc pipe */
    342         if (rpc_srv_pipe_exists_by_id(abstract) &&
    343            ndr_syntax_id_equal(transfer, &ndr_transfer_syntax)) {
    344                 DEBUG(3, ("check_bind_req: \\PIPE\\%s -> \\PIPE\\%s\n",
    345                         rpc_srv_get_pipe_cli_name(abstract),
    346                         rpc_srv_get_pipe_srv_name(abstract)));
    347         } else {
     386        if (!rpc_srv_pipe_exists_by_id(abstract)) {
    348387                return false;
    349388        }
     389
     390
     391
     392
    350393
    351394        context_fns = SMB_MALLOC_P(struct pipe_rpc_fns);
    … …  
    355398        }
    356399
     400
     401
     402
     403
     404
    357405        context_fns->next = context_fns->prev = NULL;
    358406        context_fns->n_cmds = rpc_srv_get_pipe_num_cmds(abstract);
    359407        context_fns->cmds = rpc_srv_get_pipe_cmds(abstract);
    360408        context_fns->context_id = context_id;
     409
     410
     411
     412
     413
     414
     415
     416
     417
     418
     419
     420
     421
     422
     423
     424
     425
     426
     427
     428
     429
     430
     431
     432
     433
     434
     435
     436
     437
     438
     439
     440
     441
     442
     443
     444
     445
     446
     447
     448
     449
    361450
    362451        /* add to the list of open contexts */
    … …  
    446535        p->auth.auth_ctx = spnego_ctx;
    447536        p->auth.auth_type = DCERPC_AUTH_TYPE_SPNEGO;
     537
    448538
    449539        DEBUG(10, ("SPNEGO auth started\n"));
    … …  
    556646        p->auth.auth_ctx = schannel_auth;
    557647        p->auth.auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
     648
    558649
    559650        p->pipe_bound = True;
    … …  
    600691        p->auth.auth_ctx = ntlmssp_state;
    601692        p->auth.auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
     693
    602694
    603695        DEBUG(10, (__location__ ": NTLMSSP auth started\n"));
    … …  
    774866        void *mech_ctx;
    775867        NTSTATUS status;
     868
     869
     870
     871
     872
    776873
    777874        switch (p->auth.auth_type) {
    … …  
    866963        DATA_BLOB auth_blob = data_blob_null;
    867964
    868         /* No rebinds on a bound pipe - use alter context. */
    869         if (p->pipe_bound) {
    870                 DEBUG(2,("api_pipe_bind_req: rejecting bind request on bound "
    871                          "pipe %s.\n",
    872                          get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     965        if (!p->allow_bind) {
     966                DEBUG(2,("Pipe not in allow bind state\n"));
    873967                return setup_bind_nak(p, pkt);
    874968        }
     969
     970
     971
     972
     973
     974
     975
     976
     977
     978
     979
     980
     981
     982
     983
     984
     985
     986
     987
     988
    875989
    876990        if (pkt->u.bind.num_contexts == 0) {
    877                 DEBUG(0, ("api_pipe_bind_req: no rpc contexts around\n"));
     991                DEBUG(1, ("api_pipe_bind_req: no rpc contexts around\n"));
     992                goto err_exit;
     993        }
     994
     995        if (pkt->u.bind.ctx_list[0].num_transfer_syntaxes == 0) {
     996                DEBUG(1, ("api_pipe_bind_req: no transfer syntaxes around\n"));
    878997                goto err_exit;
    879998        }
    … …  
    9591078         */
    9601079        if (pkt->auth_length) {
    961                 /* Quick length check. Won't catch a bad auth footer,
    962                  * prevents overrun. */
    963 
    964                 if (pkt->frag_length < RPC_HEADER_LEN +
    965                                         DCERPC_AUTH_TRAILER_LENGTH +
    966                                         pkt->auth_length) {
    967                         DEBUG(0,("api_pipe_bind_req: auth_len (%u) "
    968                                 "too long for fragment %u.\n",
    969                                 (unsigned int)pkt->auth_length,
    970                                 (unsigned int)pkt->frag_length));
    971                         goto err_exit;
    972                 }
    973 
    9741080                /*
    9751081                 * Decode the authentication verifier.
    9761082                 */
    977                 status = dcerpc_pull_dcerpc_auth(pkt,
    978                                                  &pkt->u.bind.auth_info,
    979                                                  &auth_info, p->endian);
     1083                status = dcerpc_pull_pkt,
     1084                                                 &pkt->u.bind.auth_info,
     1085                                                 );
    9801086                if (!NT_STATUS_IS_OK(status)) {
    9811087                        DEBUG(0, ("Unable to unmarshall dcerpc_auth.\n"));
    … …  
    10711177                /* The session key was initialized from the SMB
    10721178                 * session in make_internal_rpc_pipe_p */
     1179
    10731180        }
    10741181
    … …  
    11121219                DEBUG(0, ("Failed to marshall bind_ack packet. (%s)\n",
    11131220                          nt_errstr(status)));
     1221
    11141222        }
    11151223
    11161224        if (auth_resp.length) {
    1117 
    11181225                status = dcerpc_push_dcerpc_auth(pkt,
    11191226                                                 auth_type,
    11201227                                                 auth_info.auth_level,
    1121                                                  0,
    1122                                                  1, /* auth_context_id */
     1228                                                 0,
     1229                                                 
    11231230                                                 &auth_resp,
    11241231                                                 &auth_blob);
    … …  
    11511258
    11521259        TALLOC_FREE(auth_blob.data);
     1260
     1261
     1262
     1263
     1264
     1265
     1266
     1267
     1268
     1269
     1270
     1271
     1272
     1273
     1274
     1275
    11531276        return True;
    11541277
    … …  
    11751298        DEBUG(5, ("api_pipe_bind_auth3: decode request. %d\n", __LINE__));
    11761299
     1300
     1301
     1302
     1303
     1304
     1305
     1306
     1307
     1308
     1309
     1310
     1311
     1312
     1313
     1314
     1315
     1316
     1317
     1318
     1319
     1320
     1321
     1322
     1323
     1324
     1325
     1326
     1327
     1328
     1329
     1330
    11771331        if (pkt->auth_length == 0) {
    1178                 DEBUG(0, ("No auth field sent for bind request!\n"));
     1332                DEBUG( request!\n"));
    11791333                goto err;
    11801334        }
    11811335
    1182         /* Ensure there's enough data for an authenticated request. */
    1183         if (pkt->frag_length < RPC_HEADER_LEN
    1184                                 + DCERPC_AUTH_TRAILER_LENGTH
    1185                                 + pkt->auth_length) {
    1186                         DEBUG(0,("api_pipe_ntlmssp_auth_process: auth_len "
    1187                                 "%u is too large.\n",
    1188                         (unsigned int)pkt->auth_length));
    1189                 goto err;
    1190         }
    1191 
    11921336        /*
    11931337         * Decode the authentication verifier response.
    11941338         */
    11951339
    1196         status = dcerpc_pull_dcerpc_auth(pkt,
    1197                                          &pkt->u.auth3.auth_info,
    1198                                          &auth_info, p->endian);
     1340        status = dcerpc_pull_pkt,
     1341                                         &pkt->u.auth3.auth_info,
     1342                                         );
    11991343        if (!NT_STATUS_IS_OK(status)) {
    12001344                DEBUG(0, ("Failed to unmarshall dcerpc_auth.\n"));
    … …  
    12111355                          "but auth was started as type %d!\n",
    12121356                          auth_info.auth_type, p->auth.auth_type));
     1357
     1358
     1359
     1360
     1361
     1362
     1363
     1364
     1365
     1366
     1367
     1368
     1369
     1370
     1371
    12131372                goto err;
    12141373        }
    … …  
    12661425
    12671426err:
     1427
     1428
     1429
     1430
    12681431
    12691432        TALLOC_FREE(p->auth.auth_ctx);
    … …  
    12831446        NTSTATUS status;
    12841447        union dcerpc_payload u;
    1285         struct dcerpc_ack_ctx bind_ack_ctx;
     1448        struct dcerpc_ack_ctx _ack_ctx;
    12861449        DATA_BLOB auth_resp = data_blob_null;
    12871450        DATA_BLOB auth_blob = data_blob_null;
    … …  
    12931456        DEBUG(5,("api_pipe_alter_context: make response. %d\n", __LINE__));
    12941457
    1295         if (pkt->u.bind.assoc_group_id != 0) {
    1296                 assoc_gid = pkt->u.bind.assoc_group_id;
     1458        if (!p->allow_alter) {
     1459                DEBUG(1, ("Pipe not in allow alter state.\n"));
     1460                goto err_exit;
     1461        }
     1462
     1463        status = dcerpc_verify_ncacn_packet_header(pkt,
     1464                        DCERPC_PKT_ALTER,
     1465                        pkt->u.alter.auth_info.length,
     1466                        0, /* required flags */
     1467                        DCERPC_PFC_FLAG_FIRST |
     1468                        DCERPC_PFC_FLAG_LAST |
     1469                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
     1470                        0x08 | /* this is not defined, but should be ignored */
     1471                        DCERPC_PFC_FLAG_CONC_MPX |
     1472                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
     1473                        DCERPC_PFC_FLAG_MAYBE |
     1474                        DCERPC_PFC_FLAG_OBJECT_UUID);
     1475        if (!NT_STATUS_IS_OK(status)) {
     1476                DEBUG(1, ("api_pipe_alter_context: invalid pdu: %s\n",
     1477                          nt_errstr(status)));
     1478                NDR_PRINT_DEBUG(ncacn_packet, pkt);
     1479                goto err_exit;
     1480        }
     1481
     1482        if (pkt->u.alter.num_contexts == 0) {
     1483                DEBUG(1, ("api_pipe_alter_context: no rpc contexts around\n"));
     1484                goto err_exit;
     1485        }
     1486
     1487        if (pkt->u.alter.ctx_list[0].num_transfer_syntaxes == 0) {
     1488                DEBUG(1, ("api_pipe_alter_context: no transfer syntaxes around\n"));
     1489                goto err_exit;
     1490        }
     1491
     1492        if (pkt->u.alter.assoc_group_id != 0) {
     1493                assoc_gid = pkt->u.alter.assoc_group_id;
    12971494        } else {
    12981495                assoc_gid = 0x53f0;
    … …  
    13041501
    13051502        /* If the requested abstract synt uuid doesn't match our client pipe,
    1306                 reject the bind_ack & set the transfer interface synt to all 0's,
     1503                reject the _ack & set the transfer interface synt to all 0's,
    13071504                ver 0 (observed when NT5 attempts to bind to abstract interfaces
    13081505                unknown to NT4)
    … …  
    13101507
    13111508        if (check_bind_req(p,
    1312                         &pkt->u.bind.ctx_list[0].abstract_syntax,
    1313                         &pkt->u.bind.ctx_list[0].transfer_syntaxes[0],
    1314                         pkt->u.bind.ctx_list[0].context_id)) {
    1315 
    1316                 bind_ack_ctx.result = 0;
    1317                 bind_ack_ctx.reason = 0;
    1318                 bind_ack_ctx.syntax = pkt->u.bind.ctx_list[0].transfer_syntaxes[0];
     1509                        &pkt->u..ctx_list[0].abstract_syntax,
     1510                        &pkt->u..ctx_list[0].transfer_syntaxes[0],
     1511                        pkt->u..ctx_list[0].context_id)) {
     1512
     1513                _ack_ctx.result = 0;
     1514                _ack_ctx.reason = 0;
     1515                .ctx_list[0].transfer_syntaxes[0];
    13191516        } else {
    1320                 p->pipe_bound = False;
    13211517                /* Rejection reason: abstract syntax not supported */
    1322                 bind_ack_ctx.result = DCERPC_BIND_PROVIDER_REJECT;
    1323                 bind_ack_ctx.reason = DCERPC_BIND_REASON_ASYNTAX;
    1324                 bind_ack_ctx.syntax = null_ndr_syntax_id;
     1518                _ack_ctx.result = DCERPC_BIND_PROVIDER_REJECT;
     1519                _ack_ctx.reason = DCERPC_BIND_REASON_ASYNTAX;
     1520                _ack_ctx.syntax = null_ndr_syntax_id;
    13251521        }
    13261522
    … …  
    13291525         */
    13301526        if (pkt->auth_length) {
    1331                 /* Quick length check. Won't catch a bad auth footer,
    1332                  * prevents overrun. */
    1333 
    1334                 if (pkt->frag_length < RPC_HEADER_LEN +
    1335                                         DCERPC_AUTH_TRAILER_LENGTH +
    1336                                         pkt->auth_length) {
    1337                         DEBUG(0,("api_pipe_alter_context: auth_len (%u) "
    1338                                 "too long for fragment %u.\n",
    1339                                 (unsigned int)pkt->auth_length,
    1340                                 (unsigned int)pkt->frag_length ));
    1341                         goto err_exit;
    1342                 }
    1343 
    1344                 status = dcerpc_pull_dcerpc_auth(pkt,
    1345                                                  &pkt->u.bind.auth_info,
    1346                                                  &auth_info, p->endian);
    1347                 if (!NT_STATUS_IS_OK(status)) {
    1348                         DEBUG(0, ("Unable to unmarshall dcerpc_auth.\n"));
    1349                         goto err_exit;
    1350                 }
    1351 
    13521527                /* We can only finish if the pipe is unbound for now */
    13531528                if (p->pipe_bound) {
    … …  
    13571532                }
    13581533
     1534
     1535
     1536
     1537
     1538
     1539
     1540
     1541
    13591542                if (auth_info.auth_type != p->auth.auth_type) {
    13601543                        DEBUG(0, ("Auth type mismatch! Client sent %d, "
    … …  
    13641547                }
    13651548
     1549
     1550
     1551
     1552
     1553
     1554
     1555
     1556
     1557
     1558
     1559
     1560
     1561
     1562
    13661563
    13671564                switch (auth_info.auth_type) {
    … …  
    14301627
    14311628        u.alter_resp.num_results = 1;
    1432         u.alter_resp.ctx_list = &bind_ack_ctx;
     1629        u.alter_resp.ctx_list = &_ack_ctx;
    14331630
    14341631        /* NOTE: We leave the auth_info empty so we can calculate the padding
    … …  
    14501647                                          &p->out_data.frag);
    14511648        if (!NT_STATUS_IS_OK(status)) {
    1452                 DEBUG(0, ("Failed to marshall bind_ack packet. (%s)\n",
     1649                DEBUG(0, ("Failed to marshall packet. (%s)\n",
    14531650                          nt_errstr(status)));
     1651
    14541652        }
    14551653
    … …  
    14681666                                                 auth_info.auth_level,
    14691667                                                 pad_len,
    1470                                                  1, /* auth_context_id */
     1668                                                 
    14711669                                                 &auth_resp,
    14721670                                                 &auth_blob);
    … …  
    15421740
    15431741static bool api_rpcTNP(struct pipes_struct *p, struct ncacn_packet *pkt,
    1544                        const struct api_struct *api_rpc_cmds, int n_cmds);
     1742                       const struct api_struct *api_rpc_cmds, int n_cmds,
     1743                       const struct ndr_syntax_id *syntax);
     1744
     1745static bool srv_pipe_check_verification_trailer(struct pipes_struct *p,
     1746                                                struct ncacn_packet *pkt,
     1747                                                struct pipe_rpc_fns *pipe_fns)
     1748{
     1749        TALLOC_CTX *frame = talloc_stackframe();
     1750        struct dcerpc_sec_verification_trailer *vt = NULL;
     1751        const uint32_t bitmask1 = 0;
     1752        const struct dcerpc_sec_vt_pcontext pcontext = {
     1753                .abstract_syntax = pipe_fns->syntax,
     1754                .transfer_syntax = ndr_transfer_syntax,
     1755        };
     1756        const struct dcerpc_sec_vt_header2 header2 =
     1757               dcerpc_sec_vt_header2_from_ncacn_packet(pkt);
     1758        struct ndr_pull *ndr;
     1759        enum ndr_err_code ndr_err;
     1760        bool ret = false;
     1761
     1762        ndr = ndr_pull_init_blob(&p->in_data.data, frame);
     1763        if (ndr == NULL) {
     1764                goto done;
     1765        }
     1766
     1767        ndr_err = ndr_pop_dcerpc_sec_verification_trailer(ndr, frame, &vt);
     1768        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
     1769                goto done;
     1770        }
     1771
     1772        ret = dcerpc_sec_verification_trailer_check(vt, &bitmask1,
     1773                                                    &pcontext, &header2);
     1774done:
     1775        TALLOC_FREE(frame);
     1776        return ret;
     1777}
    15451778
    15461779/****************************************************************************
    … …  
    15531786                                struct ncacn_packet *pkt)
    15541787{
     1788
    15551789        bool ret = False;
    1556         bool changed_user = False;
    15571790        PIPE_RPC_FNS *pipe_fns;
    1558 
    1559         if (p->pipe_bound &&
    1560             ((p->auth.auth_type == DCERPC_AUTH_TYPE_NTLMSSP) ||
    1561              (p->auth.auth_type == DCERPC_AUTH_TYPE_KRB5) ||
    1562              (p->auth.auth_type == DCERPC_AUTH_TYPE_SPNEGO))) {
    1563                 if(!become_authenticated_pipe_user(p->session_info)) {
    1564                         data_blob_free(&p->out_data.rdata);
    1565                         return False;
    1566                 }
    1567                 changed_user = True;
    1568         }
    1569 
    1570         DEBUG(5, ("Requested \\PIPE\\%s\n",
    1571                   get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     1791        const char *interface_name = NULL;
     1792
     1793        if (!p->pipe_bound) {
     1794                DEBUG(1, ("Pipe not bound!\n"));
     1795                data_blob_free(&p->out_data.rdata);
     1796                TALLOC_FREE(frame);
     1797                return false;
     1798        }
    15721799
    15731800        /* get the set of RPC functions for this context */
    … …  
    15751802        pipe_fns = find_pipe_fns_by_context(p->contexts,
    15761803                                            pkt->u.request.context_id);
    1577 
    1578         if ( pipe_fns ) {
    1579                 TALLOC_CTX *frame = talloc_stackframe();
    1580                 ret = api_rpcTNP(p, pkt, pipe_fns->cmds, pipe_fns->n_cmds);
     1804        if (pipe_fns == NULL) {
     1805                DEBUG(0, ("No rpc function table associated with context "
     1806                          "[%d]\n",
     1807                          pkt->u.request.context_id));
     1808                data_blob_free(&p->out_data.rdata);
    15811809                TALLOC_FREE(frame);
    1582         }
    1583         else {
    1584                 DEBUG(0, ("No rpc function table associated with context "
    1585                           "[%d] on pipe [%s]\n",
    1586                           pkt->u.request.context_id,
    1587                           get_pipe_name_from_syntax(talloc_tos(),
    1588                                                     &p->syntax)));
    1589         }
    1590 
    1591         if (changed_user) {
    1592                 unbecome_authenticated_pipe_user();
    1593         }
    1594 
     1810                return false;
     1811        }
     1812
     1813        interface_name = get_pipe_name_from_syntax(talloc_tos(),
     1814                                                   &pipe_fns->syntax);
     1815
     1816        SMB_ASSERT(interface_name != NULL);
     1817
     1818        DEBUG(5, ("Requested \\PIPE\\%s\n",
     1819                  interface_name));
     1820
     1821        switch (p->auth.auth_level) {
     1822        case DCERPC_AUTH_LEVEL_NONE:
     1823        case DCERPC_AUTH_LEVEL_INTEGRITY:
     1824        case DCERPC_AUTH_LEVEL_PRIVACY:
     1825                break;
     1826        default:
     1827                if (!pipe_fns->allow_connect) {
     1828                        DEBUG(1, ("%s: restrict auth_level_connect access "
     1829                                  "to [%s] with auth[type=0x%x,level=0x%x] "
     1830                                  "on [%s] from [%s]\n",
     1831                                  __func__, interface_name,
     1832                                  p->auth.auth_type,
     1833                                  p->auth.auth_level,
     1834                                  derpc_transport_string_by_transport(p->transport),
     1835                                  p->client_id->name));
     1836
     1837                        setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_ACCESS_DENIED));
     1838                        TALLOC_FREE(frame);
     1839                        return true;
     1840                }
     1841                break;
     1842        }
     1843
     1844        if (!srv_pipe_check_verification_trailer(p, pkt, pipe_fns)) {
     1845                DEBUG(1, ("srv_pipe_check_verification_trailer: failed\n"));
     1846                set_incoming_fault(p);
     1847                setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_ACCESS_DENIED));
     1848                data_blob_free(&p->out_data.rdata);
     1849                TALLOC_FREE(frame);
     1850                return true;
     1851        }
     1852
     1853        if (!become_authenticated_pipe_user(p->session_info)) {
     1854                DEBUG(1, ("Failed to become pipe user!\n"));
     1855                data_blob_free(&p->out_data.rdata);
     1856                TALLOC_FREE(frame);
     1857                return false;
     1858        }
     1859
     1860        ret = api_rpcTNP(p, pkt, pipe_fns->cmds, pipe_fns->n_cmds,
     1861                         &pipe_fns->syntax);
     1862        unbecome_authenticated_pipe_user();
     1863
     1864        TALLOC_FREE(frame);
    15951865        return ret;
    15961866}
    … …  
    16011871
    16021872static bool api_rpcTNP(struct pipes_struct *p, struct ncacn_packet *pkt,
    1603                        const struct api_struct *api_rpc_cmds, int n_cmds)
     1873                       const struct api_struct *api_rpc_cmds, int n_cmds,
     1874                       const struct ndr_syntax_id *syntax)
    16041875{
    16051876        int fn_num;
    … …  
    16081879        /* interpret the command */
    16091880        DEBUG(4,("api_rpcTNP: %s op 0x%x - ",
    1610                  get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
     1881                 get_pipe_name_from_syntax(talloc_tos(), syntax),
    16111882                 pkt->u.request.opnum));
    16121883
    … …  
    16141885                fstring name;
    16151886                slprintf(name, sizeof(name)-1, "in_%s",
    1616                          get_pipe_name_from_syntax(talloc_tos(), &p->syntax));
     1887                         get_pipe_name_from_syntax(talloc_tos(), syntax));
    16171888                dump_pdu_region(name, pkt->u.request.opnum,
    16181889                                &p->in_data.data, 0,
    … …  
    16471918        if(!api_rpc_cmds[fn_num].fn(p)) {
    16481919                DEBUG(0,("api_rpcTNP: %s: %s failed.\n",
    1649                          get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
     1920                         get_pipe_name_from_syntax(talloc_tos(), syntax),
    16501921                         api_rpc_cmds[fn_num].name));
    16511922                data_blob_free(&p->out_data.rdata);
    … …  
    16531924        }
    16541925
    1655         if (p->bad_handle_fault_state) {
    1656                 DEBUG(4,("api_rpcTNP: bad handle fault return.\n"));
    1657                 p->bad_handle_fault_state = False;
    1658                 setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_CONTEXT_MISMATCH));
    1659                 return True;
    1660         }
    1661 
    1662         if (p->rng_fault_state) {
    1663                 DEBUG(4, ("api_rpcTNP: rng fault return\n"));
    1664                 p->rng_fault_state = False;
    1665                 setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
    1666                 return True;
     1926        if (p->fault_state) {
     1927                DEBUG(4,("api_rpcTNP: fault(%d) return.\n", p->fault_state));
     1928                setup_fault_pdu(p, NT_STATUS(p->fault_state));
     1929                p->fault_state = 0;
     1930                return true;
    16671931        }
    16681932
    … …  
    16701934                fstring name;
    16711935                slprintf(name, sizeof(name)-1, "out_%s",
    1672                          get_pipe_name_from_syntax(talloc_tos(), &p->syntax));
     1936                         get_pipe_name_from_syntax(talloc_tos(), syntax));
    16731937                dump_pdu_region(name, pkt->u.request.opnum,
    16741938                                &p->out_data.rdata, offset1,
    … …  
    16771941
    16781942        DEBUG(5,("api_rpcTNP: called %s successfully\n",
    1679                  get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     1943                 get_pipe_name_from_syntax(talloc_tos(), syntax)));
    16801944
    16811945        /* Check for buffer underflow in rpc parsing */
    … …  
    17191983        p->in_data.pdu_needed_len = 0;
    17201984        p->in_data.pdu.length = 0;
    1721         p->fault_state = True;
    1722         DEBUG(10, ("set_incoming_fault: Setting fault state on pipe %s\n",
    1723                    get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     1985        p->fault_state = DCERPC_NCA_S_PROTO_ERROR;
     1986
     1987        p->allow_alter = false;
     1988        p->allow_auth3 = false;
     1989        p->pipe_bound = false;
     1990
     1991        DEBUG(10, ("Setting fault state\n"));
    17241992}
    17251993
    … …  
    17301998        NTSTATUS status;
    17311999        size_t hdr_size = DCERPC_REQUEST_LENGTH;
    1732         size_t pad_len;
    17332000
    17342001        DEBUG(10, ("Checking request auth.\n"));
    … …  
    17412008        status = dcerpc_check_auth(auth, pkt,
    17422009                                   &pkt->u.request.stub_and_verifier,
    1743                                    hdr_size, raw_pkt,
    1744                                    &pad_len);
     2010                                   hdr_size, raw_pkt);
    17452011        if (!NT_STATUS_IS_OK(status)) {
    17462012                return status;
    1747         }
    1748 
    1749 
    1750         /* remove padding and auth trailer,
    1751          * this way the caller will get just the data */
    1752         if (pkt->auth_length) {
    1753                 size_t trail_len = pad_len
    1754                                         + DCERPC_AUTH_TRAILER_LENGTH
    1755                                         + pkt->auth_length;
    1756                 if (pkt->u.request.stub_and_verifier.length < trail_len) {
    1757                         return NT_STATUS_INFO_LENGTH_MISMATCH;
    1758                 }
    1759                 pkt->u.request.stub_and_verifier.length -= trail_len;
    17602013        }
    17612014
    … …  
    17772030                set_incoming_fault(p);
    17782031                return False;
     2032
     2033
     2034
     2035
     2036
     2037
     2038
     2039
     2040
     2041
     2042
     2043
     2044
     2045
     2046
     2047
     2048
     2049
     2050
     2051
     2052
     2053
     2054
    17792055        }
    17802056
    … …  
    20282304                                                                &p->syntax)));
    20292305                set_incoming_fault(p);
    2030                 setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
     2306                setup_fault_pdu(p, NT_STATUS(DCERPC__ERROR));
    20312307                TALLOC_FREE(pkt);
    20322308        } else {

  • trunk/server/source3/rpc_server/srvsvc/srv_srvsvc_nt.c

    r918 r920  
    25492549                              struct srvsvc_NetCharDevEnum *r)
    25502550{
    2551         p->rng_fault_state = True;
     2551        p->;
    25522552        return WERR_NOT_SUPPORTED;
    25532553}
    … …  
    25562556                                 struct srvsvc_NetCharDevGetInfo *r)
    25572557{
    2558         p->rng_fault_state = True;
     2558        p->;
    25592559        return WERR_NOT_SUPPORTED;
    25602560}
    … …  
    25632563                                 struct srvsvc_NetCharDevControl *r)
    25642564{
    2565         p->rng_fault_state = True;
     2565        p->;
    25662566        return WERR_NOT_SUPPORTED;
    25672567}
    … …  
    25702570                               struct srvsvc_NetCharDevQEnum *r)
    25712571{
    2572         p->rng_fault_state = True;
     2572        p->;
    25732573        return WERR_NOT_SUPPORTED;
    25742574}
    … …  
    25772577                                  struct srvsvc_NetCharDevQGetInfo *r)
    25782578{
    2579         p->rng_fault_state = True;
     2579        p->;
    25802580        return WERR_NOT_SUPPORTED;
    25812581}
    … …  
    25842584                                  struct srvsvc_NetCharDevQSetInfo *r)
    25852585{
    2586         p->rng_fault_state = True;
     2586        p->;
    25872587        return WERR_NOT_SUPPORTED;
    25882588}
    … …  
    25912591                                struct srvsvc_NetCharDevQPurge *r)
    25922592{
    2593         p->rng_fault_state = True;
     2593        p->;
    25942594        return WERR_NOT_SUPPORTED;
    25952595}
    … …  
    25982598                                    struct srvsvc_NetCharDevQPurgeSelf *r)
    25992599{
    2600         p->rng_fault_state = True;
     2600        p->;
    26012601        return WERR_NOT_SUPPORTED;
    26022602}
    … …  
    26052605                              struct srvsvc_NetFileGetInfo *r)
    26062606{
    2607         p->rng_fault_state = True;
     2607        p->;
    26082608        return WERR_NOT_SUPPORTED;
    26092609}
    … …  
    26122612                             struct srvsvc_NetShareCheck *r)
    26132613{
    2614         p->rng_fault_state = True;
     2614        p->;
    26152615        return WERR_NOT_SUPPORTED;
    26162616}
    … …  
    26192619                                      struct srvsvc_NetServerStatisticsGet *r)
    26202620{
    2621         p->rng_fault_state = True;
     2621        p->;
    26222622        return WERR_NOT_SUPPORTED;
    26232623}
    … …  
    26262626                               struct srvsvc_NetTransportAdd *r)
    26272627{
    2628         p->rng_fault_state = True;
     2628        p->;
    26292629        return WERR_NOT_SUPPORTED;
    26302630}
    … …  
    26332633                                struct srvsvc_NetTransportEnum *r)
    26342634{
    2635         p->rng_fault_state = True;
     2635        p->;
    26362636        return WERR_NOT_SUPPORTED;
    26372637}
    … …  
    26402640                               struct srvsvc_NetTransportDel *r)
    26412641{
    2642         p->rng_fault_state = True;
     2642        p->;
    26432643        return WERR_NOT_SUPPORTED;
    26442644}
    … …  
    26472647                                 struct srvsvc_NetSetServiceBits *r)
    26482648{
    2649         p->rng_fault_state = True;
     2649        p->;
    26502650        return WERR_NOT_SUPPORTED;
    26512651}
    … …  
    26542654                           struct srvsvc_NetPathType *r)
    26552655{
    2656         p->rng_fault_state = True;
     2656        p->;
    26572657        return WERR_NOT_SUPPORTED;
    26582658}
    … …  
    26612661                                   struct srvsvc_NetPathCanonicalize *r)
    26622662{
    2663         p->rng_fault_state = True;
     2663        p->;
    26642664        return WERR_NOT_SUPPORTED;
    26652665}
    … …  
    26682668                              struct srvsvc_NetPathCompare *r)
    26692669{
    2670         p->rng_fault_state = True;
     2670        p->;
    26712671        return WERR_NOT_SUPPORTED;
    26722672}
    … …  
    26752675                                      struct srvsvc_NETRPRNAMECANONICALIZE *r)
    26762676{
    2677         p->rng_fault_state = True;
     2677        p->;
    26782678        return WERR_NOT_SUPPORTED;
    26792679}
    … …  
    26822682                                struct srvsvc_NetPRNameCompare *r)
    26832683{
    2684         p->rng_fault_state = True;
     2684        p->;
    26852685        return WERR_NOT_SUPPORTED;
    26862686}
    … …  
    26892689                                struct srvsvc_NetShareDelStart *r)
    26902690{
    2691         p->rng_fault_state = True;
     2691        p->;
    26922692        return WERR_NOT_SUPPORTED;
    26932693}
    … …  
    26962696                                 struct srvsvc_NetShareDelCommit *r)
    26972697{
    2698         p->rng_fault_state = True;
     2698        p->;
    26992699        return WERR_NOT_SUPPORTED;
    27002700}
    … …  
    27032703                                       struct srvsvc_NetServerTransportAddEx *r)
    27042704{
    2705         p->rng_fault_state = True;
     2705        p->;
    27062706        return WERR_NOT_SUPPORTED;
    27072707}
    … …  
    27102710                                         struct srvsvc_NetServerSetServiceBitsEx *r)
    27112711{
    2712         p->rng_fault_state = True;
     2712        p->;
    27132713        return WERR_NOT_SUPPORTED;
    27142714}
    … …  
    27172717                                 struct srvsvc_NETRDFSGETVERSION *r)
    27182718{
    2719         p->rng_fault_state = True;
     2719        p->;
    27202720        return WERR_NOT_SUPPORTED;
    27212721}
    … …  
    27242724                                           struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
    27252725{
    2726         p->rng_fault_state = True;
     2726        p->;
    27272727        return WERR_NOT_SUPPORTED;
    27282728}
    … …  
    27312731                                           struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
    27322732{
    2733         p->rng_fault_state = True;
     2733        p->;
    27342734        return WERR_NOT_SUPPORTED;
    27352735}
    … …  
    27382738                                          struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
    27392739{
    2740         p->rng_fault_state = True;
     2740        p->;
    27412741        return WERR_NOT_SUPPORTED;
    27422742}
    … …  
    27452745                                    struct srvsvc_NETRDFSSETSERVERINFO *r)
    27462746{
    2747         p->rng_fault_state = True;
     2747        p->;
    27482748        return WERR_NOT_SUPPORTED;
    27492749}
    … …  
    27522752                                      struct srvsvc_NETRDFSCREATEEXITPOINT *r)
    27532753{
    2754         p->rng_fault_state = True;
     2754        p->;
    27552755        return WERR_NOT_SUPPORTED;
    27562756}
    … …  
    27592759                                      struct srvsvc_NETRDFSDELETEEXITPOINT *r)
    27602760{
    2761         p->rng_fault_state = True;
     2761        p->;
    27622762        return WERR_NOT_SUPPORTED;
    27632763}
    … …  
    27662766                                   struct srvsvc_NETRDFSMODIFYPREFIX *r)
    27672767{
    2768         p->rng_fault_state = True;
     2768        p->;
    27692769        return WERR_NOT_SUPPORTED;
    27702770}
    … …  
    27732773                                     struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
    27742774{
    2775         p->rng_fault_state = True;
     2775        p->;
    27762776        return WERR_NOT_SUPPORTED;
    27772777}
    … …  
    27802780                                            struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
    27812781{
    2782         p->rng_fault_state = True;
     2782        p->;
    27832783        return WERR_NOT_SUPPORTED;
    27842784}
    … …  
    27872787                                        struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
    27882788{
    2789         p->rng_fault_state = True;
    2790         return WERR_NOT_SUPPORTED;
    2791 }
     2789        p->;
     2790        return WERR_NOT_SUPPORTED;
     2791}

  • trunk/server/source3/rpc_server/svcctl/srv_svcctl_nt.c

    r918 r920  
    10051005                             struct svcctl_DeleteService *r)
    10061006{
    1007         p->rng_fault_state = True;
     1007        p->;
    10081008        return WERR_NOT_SUPPORTED;
    10091009}
    … …  
    10121012                                struct svcctl_SetServiceStatus *r)
    10131013{
    1014         p->rng_fault_state = True;
     1014        p->;
    10151015        return WERR_NOT_SUPPORTED;
    10161016}
    … …  
    10191019                                      struct svcctl_NotifyBootConfigStatus *r)
    10201020{
    1021         p->rng_fault_state = True;
     1021        p->;
    10221022        return WERR_NOT_SUPPORTED;
    10231023}
    … …  
    10261026                                 struct svcctl_SCSetServiceBitsW *r)
    10271027{
    1028         p->rng_fault_state = True;
     1028        p->;
    10291029        return WERR_NOT_SUPPORTED;
    10301030}
    … …  
    10331033                                    struct svcctl_ChangeServiceConfigW *r)
    10341034{
    1035         p->rng_fault_state = True;
     1035        p->;
    10361036        return WERR_NOT_SUPPORTED;
    10371037}
    … …  
    10401040                              struct svcctl_CreateServiceW *r)
    10411041{
    1042         p->rng_fault_state = True;
     1042        p->;
    10431043        return WERR_NOT_SUPPORTED;
    10441044}
    … …  
    10471047                                       struct svcctl_QueryServiceLockStatusW *r)
    10481048{
    1049         p->rng_fault_state = True;
     1049        p->;
    10501050        return WERR_NOT_SUPPORTED;
    10511051}
    … …  
    10541054                                  struct svcctl_GetServiceKeyNameW *r)
    10551055{
    1056         p->rng_fault_state = True;
     1056        p->;
    10571057        return WERR_NOT_SUPPORTED;
    10581058}
    … …  
    10611061                                 struct svcctl_SCSetServiceBitsA *r)
    10621062{
    1063         p->rng_fault_state = True;
     1063        p->;
    10641064        return WERR_NOT_SUPPORTED;
    10651065}
    … …  
    10681068                                    struct svcctl_ChangeServiceConfigA *r)
    10691069{
    1070         p->rng_fault_state = True;
     1070        p->;
    10711071        return WERR_NOT_SUPPORTED;
    10721072}
    … …  
    10751075                              struct svcctl_CreateServiceA *r)
    10761076{
    1077         p->rng_fault_state = True;
     1077        p->;
    10781078        return WERR_NOT_SUPPORTED;
    10791079}
    … …  
    10821082                                      struct svcctl_EnumDependentServicesA *r)
    10831083{
    1084         p->rng_fault_state = True;
     1084        p->;
    10851085        return WERR_NOT_SUPPORTED;
    10861086}
    … …  
    10891089                                   struct svcctl_EnumServicesStatusA *r)
    10901090{
    1091         p->rng_fault_state = True;
     1091        p->;
    10921092        return WERR_NOT_SUPPORTED;
    10931093}
    … …  
    10961096                              struct svcctl_OpenSCManagerA *r)
    10971097{
    1098         p->rng_fault_state = True;
     1098        p->;
    10991099        return WERR_NOT_SUPPORTED;
    11001100}
    … …  
    11031103                            struct svcctl_OpenServiceA *r)
    11041104{
    1105         p->rng_fault_state = True;
     1105        p->;
    11061106        return WERR_NOT_SUPPORTED;
    11071107}
    … …  
    11101110                                   struct svcctl_QueryServiceConfigA *r)
    11111111{
    1112         p->rng_fault_state = True;
     1112        p->;
    11131113        return WERR_NOT_SUPPORTED;
    11141114}
    … …  
    11171117                                       struct svcctl_QueryServiceLockStatusA *r)
    11181118{
    1119         p->rng_fault_state = True;
     1119        p->;
    11201120        return WERR_NOT_SUPPORTED;
    11211121}
    … …  
    11241124                             struct svcctl_StartServiceA *r)
    11251125{
    1126         p->rng_fault_state = True;
     1126        p->;
    11271127        return WERR_NOT_SUPPORTED;
    11281128}
    … …  
    11311131                                      struct svcctl_GetServiceDisplayNameA *r)
    11321132{
    1133         p->rng_fault_state = True;
     1133        p->;
    11341134        return WERR_NOT_SUPPORTED;
    11351135}
    … …  
    11381138                                  struct svcctl_GetServiceKeyNameA *r)
    11391139{
    1140         p->rng_fault_state = True;
     1140        p->;
    11411141        return WERR_NOT_SUPPORTED;
    11421142}
    … …  
    11451145                                      struct svcctl_GetCurrentGroupeStateW *r)
    11461146{
    1147         p->rng_fault_state = True;
     1147        p->;
    11481148        return WERR_NOT_SUPPORTED;
    11491149}
    … …  
    11521152                                 struct svcctl_EnumServiceGroupW *r)
    11531153{
    1154         p->rng_fault_state = True;
     1154        p->;
    11551155        return WERR_NOT_SUPPORTED;
    11561156}
    … …  
    11591159                                     struct svcctl_ChangeServiceConfig2A *r)
    11601160{
    1161         p->rng_fault_state = True;
     1161        p->;
    11621162        return WERR_NOT_SUPPORTED;
    11631163}
    … …  
    11661166                                     struct svcctl_ChangeServiceConfig2W *r)
    11671167{
    1168         p->rng_fault_state = True;
     1168        p->;
    11691169        return WERR_NOT_SUPPORTED;
    11701170}
    … …  
    11731173                                    struct svcctl_QueryServiceConfig2A *r)
    11741174{
    1175         p->rng_fault_state = True;
     1175        p->;
    11761176        return WERR_NOT_SUPPORTED;
    11771177}
    … …  
    11801180                              struct EnumServicesStatusExA *r)
    11811181{
    1182         p->rng_fault_state = True;
     1182        p->;
    11831183        return WERR_NOT_SUPPORTED;
    11841184}
    … …  
    11871187                              struct EnumServicesStatusExW *r)
    11881188{
    1189         p->rng_fault_state = True;
     1189        p->;
    11901190        return WERR_NOT_SUPPORTED;
    11911191}
    … …  
    11941194                               struct svcctl_SCSendTSMessage *r)
    11951195{
    1196         p->rng_fault_state = True;
    1197         return WERR_NOT_SUPPORTED;
    1198 }
     1196        p->;
     1197        return WERR_NOT_SUPPORTED;
     1198}

  • trunk/server/source3/rpc_server/winreg/srv_winreg_nt.c

    r918 r920  
    761761           do anything */
    762762
    763         p->rng_fault_state = True;
     763        p->;
    764764        return WERR_NOT_SUPPORTED;
    765765}
    … …  
    949949           do anything */
    950950
    951         p->rng_fault_state = True;
     951        p->;
    952952        return WERR_NOT_SUPPORTED;
    953953}
    … …  
    963963           do anything */
    964964
    965         p->rng_fault_state = True;
     965        p->;
    966966        return WERR_NOT_SUPPORTED;
    967967}
    … …  
    977977           do anything */
    978978
    979         p->rng_fault_state = True;
     979        p->;
    980980        return WERR_NOT_SUPPORTED;
    981981}
    … …  
    11401140           do anything */
    11411141
    1142         p->rng_fault_state = True;
     1142        p->;
    11431143        return WERR_NOT_SUPPORTED;
    11441144}

  • trunk/server/source3/rpc_server/wkssvc/srv_wkssvc_nt.c

    r862 r920  
    406406{
    407407        /* FIXME: Add implementation code here */
    408         p->rng_fault_state = True;
     408        p->;
    409409        return WERR_NOT_SUPPORTED;
    410410}
    … …  
    609609{
    610610        /* FIXME: Add implementation code here */
    611         p->rng_fault_state = True;
     611        p->;
    612612        return WERR_NOT_SUPPORTED;
    613613}
    … …  
    620620{
    621621        /* FIXME: Add implementation code here */
    622         p->rng_fault_state = True;
     622        p->;
    623623        return WERR_NOT_SUPPORTED;
    624624}
    … …  
    631631{
    632632        /* FIXME: Add implementation code here */
    633         p->rng_fault_state = True;
     633        p->;
    634634        return WERR_NOT_SUPPORTED;
    635635}
    … …  
    642642{
    643643        /* FIXME: Add implementation code here */
    644         p->rng_fault_state = True;
     644        p->;
    645645        return WERR_NOT_SUPPORTED;
    646646}
    … …  
    653653{
    654654        /* FIXME: Add implementation code here */
    655         p->rng_fault_state = True;
     655        p->;
    656656        return WERR_NOT_SUPPORTED;
    657657}
    … …  
    664664{
    665665        /* FIXME: Add implementation code here */
    666         p->rng_fault_state = True;
     666        p->;
    667667        return WERR_NOT_SUPPORTED;
    668668}
    … …  
    675675{
    676676        /* FIXME: Add implementation code here */
    677         p->rng_fault_state = True;
     677        p->;
    678678        return WERR_NOT_SUPPORTED;
    679679}
    … …  
    686686{
    687687        /* FIXME: Add implementation code here */
    688         p->rng_fault_state = True;
     688        p->;
    689689        return WERR_NOT_SUPPORTED;
    690690}
    … …  
    697697{
    698698        /* FIXME: Add implementation code here */
    699         p->rng_fault_state = True;
     699        p->;
    700700        return WERR_NOT_SUPPORTED;
    701701}
    … …  
    708708{
    709709        /* FIXME: Add implementation code here */
    710         p->rng_fault_state = True;
     710        p->;
    711711        return WERR_NOT_SUPPORTED;
    712712}
    … …  
    719719{
    720720        /* FIXME: Add implementation code here */
    721         p->rng_fault_state = True;
     721        p->;
    722722        return WERR_NOT_SUPPORTED;
    723723}
    … …  
    730730{
    731731        /* FIXME: Add implementation code here */
    732         p->rng_fault_state = True;
     732        p->;
    733733        return WERR_NOT_SUPPORTED;
    734734}
    … …  
    741741{
    742742        /* FIXME: Add implementation code here */
    743         p->rng_fault_state = True;
     743        p->;
    744744        return WERR_NOT_SUPPORTED;
    745745}
    … …  
    752752{
    753753        /* FIXME: Add implementation code here */
    754         p->rng_fault_state = True;
     754        p->;
    755755        return WERR_NOT_SUPPORTED;
    756756}
    … …  
    763763{
    764764        /* FIXME: Add implementation code here */
    765         p->rng_fault_state = True;
     765        p->;
    766766        return WERR_NOT_SUPPORTED;
    767767}
    … …  
    774774{
    775775        /* FIXME: Add implementation code here */
    776         p->rng_fault_state = True;
     776        p->;
    777777        return WERR_NOT_SUPPORTED;
    778778}
    … …  
    785785{
    786786        /* FIXME: Add implementation code here */
    787         p->rng_fault_state = True;
     787        p->;
    788788        return WERR_NOT_SUPPORTED;
    789789}
    … …  
    796796{
    797797        /* FIXME: Add implementation code here */
    798         p->rng_fault_state = True;
     798        p->;
    799799        return WERR_NOT_SUPPORTED;
    800800}
    … …  
    807807{
    808808        /* FIXME: Add implementation code here */
    809         p->rng_fault_state = True;
     809        p->;
    810810        return WERR_NOT_SUPPORTED;
    811811}
    … …  
    963963{
    964964        /* for now just return not supported */
     965
    965966        return WERR_NOT_SUPPORTED;
    966967}
    … …  
    973974{
    974975        /* FIXME: Add implementation code here */
    975         p->rng_fault_state = True;
     976        p->;
    976977        return WERR_NOT_SUPPORTED;
    977978}
    … …  
    984985{
    985986        /* FIXME: Add implementation code here */
    986         p->rng_fault_state = True;
     987        p->;
    987988        return WERR_NOT_SUPPORTED;
    988989}
    … …  
    995996{
    996997        /* FIXME: Add implementation code here */
    997         p->rng_fault_state = True;
     998        p->;
    998999        return WERR_NOT_SUPPORTED;
    9991000}
    … …  
    10061007{
    10071008        /* FIXME: Add implementation code here */
    1008         p->rng_fault_state = True;
     1009        p->;
    10091010        return WERR_NOT_SUPPORTED;
    10101011}
    … …  
    10171018{
    10181019        /* FIXME: Add implementation code here */
    1019         p->rng_fault_state = True;
     1020        p->;
    10201021        return WERR_NOT_SUPPORTED;
    10211022}
    … …  
    10281029{
    10291030        /* FIXME: Add implementation code here */
    1030         p->rng_fault_state = True;
    1031         return WERR_NOT_SUPPORTED;
    1032 }
     1031        p->;
     1032        return WERR_NOT_SUPPORTED;
     1033}
Note: See TracChangeset for help on using the changeset viewer.