Ignore:
Timestamp:
Jun 9, 2016, 2:17:22 PM (9 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: apply latest security patches to vendor

Location:
vendor/current/source3/rpc_server
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/source3/rpc_server/dfs/srv_dfs_nt.c

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

  • vendor/current/source3/rpc_server/dssetup/srv_dssetup_nt.c

    r917 r919  
    131131                                        struct dssetup_DsRoleDnsNameToFlatName *r)
    132132{
    133         p->rng_fault_state = true;
     133        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    134134        return WERR_NOT_SUPPORTED;
    135135}
    … …  
    141141                             struct dssetup_DsRoleDcAsDc *r)
    142142{
    143         p->rng_fault_state = true;
     143        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    144144        return WERR_NOT_SUPPORTED;
    145145}
    … …  
    151151                                  struct dssetup_DsRoleDcAsReplica *r)
    152152{
    153         p->rng_fault_state = true;
     153        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    154154        return WERR_NOT_SUPPORTED;
    155155}
    … …  
    161161                               struct dssetup_DsRoleDemoteDc *r)
    162162{
    163         p->rng_fault_state = true;
     163        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    164164        return WERR_NOT_SUPPORTED;
    165165}
    … …  
    171171                                             struct dssetup_DsRoleGetDcOperationProgress *r)
    172172{
    173         p->rng_fault_state = true;
     173        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    174174        return WERR_NOT_SUPPORTED;
    175175}
    … …  
    181181                                            struct dssetup_DsRoleGetDcOperationResults *r)
    182182{
    183         p->rng_fault_state = true;
     183        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    184184        return WERR_NOT_SUPPORTED;
    185185}
    … …  
    191191                             struct dssetup_DsRoleCancel *r)
    192192{
    193         p->rng_fault_state = true;
     193        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    194194        return WERR_NOT_SUPPORTED;
    195195}
    … …  
    201201                                                struct dssetup_DsRoleServerSaveStateForUpgrade *r)
    202202{
    203         p->rng_fault_state = true;
     203        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    204204        return WERR_NOT_SUPPORTED;
    205205}
    … …  
    211211                                             struct dssetup_DsRoleUpgradeDownlevelServer *r)
    212212{
    213         p->rng_fault_state = true;
     213        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     224        return WERR_NOT_SUPPORTED;
     225}

  • vendor/current/source3/rpc_server/echo/srv_echo_nt.c

    r917 r919  
    8888void _echo_TestCall(struct pipes_struct *p, struct echo_TestCall *r)
    8989{
    90         p->rng_fault_state = True;
     90        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    9191        return;
    9292}
    … …  
    9494NTSTATUS _echo_TestCall2(struct pipes_struct *p, struct echo_TestCall2 *r)
    9595{
    96         p->rng_fault_state = True;
     96        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    109109        return;
    110110}
    … …  
    112112void _echo_TestSurrounding(struct pipes_struct *p, struct echo_TestSurrounding *r)
    113113{
    114         p->rng_fault_state = True;
     114        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    115115        return;
    116116}
    … …  
    118118uint16 _echo_TestDoublePointer(struct pipes_struct *p, struct echo_TestDoublePointer *r)
    119119{
    120         p->rng_fault_state = True;
     120        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    121121        return 0;
    122122}

  • vendor/current/source3/rpc_server/epmapper/srv_epmapper.c

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

  • vendor/current/source3/rpc_server/eventlog/srv_eventlog_nt.c

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

  • vendor/current/source3/rpc_server/lsa/srv_lsa_nt.c

    r917 r919  
    818818
    819819        if ((pdb_capabilities() & PDB_CAP_ADS) == 0) {
    820                 p->rng_fault_state = True;
     820                p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32143214        return NT_STATUS_NOT_IMPLEMENTED;
    32153215}
    … …  
    32183218                             struct lsa_ChangePassword *r)
    32193219{
    3220         p->rng_fault_state = True;
     3220        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32333233        return NT_STATUS_NOT_IMPLEMENTED;
    32343234}
    … …  
    32373237                                  struct lsa_GetQuotasForAccount *r)
    32383238{
    3239         p->rng_fault_state = True;
     3239        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32403240        return NT_STATUS_NOT_IMPLEMENTED;
    32413241}
    … …  
    32443244                                  struct lsa_SetQuotasForAccount *r)
    32453245{
    3246         p->rng_fault_state = True;
     3246        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32473247        return NT_STATUS_NOT_IMPLEMENTED;
    32483248}
    … …  
    32513251                                          struct lsa_SetInformationTrustedDomain *r)
    32523252{
    3253         p->rng_fault_state = True;
     3253        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32603260        return NT_STATUS_NOT_IMPLEMENTED;
    32613261}
    … …  
    32643264                                   struct lsa_SetTrustedDomainInfo *r)
    32653265{
    3266         p->rng_fault_state = True;
     3266        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32673267        return NT_STATUS_NOT_IMPLEMENTED;
    32683268}
    … …  
    32713271                               struct lsa_StorePrivateData *r)
    32723272{
    3273         p->rng_fault_state = True;
     3273        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32743274        return NT_STATUS_NOT_IMPLEMENTED;
    32753275}
    … …  
    32783278                                  struct lsa_RetrievePrivateData *r)
    32793279{
    3280         p->rng_fault_state = True;
     3280        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32813281        return NT_STATUS_NOT_IMPLEMENTED;
    32823282}
    … …  
    32853285                             struct lsa_SetInfoPolicy2 *r)
    32863286{
    3287         p->rng_fault_state = True;
     3287        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32883288        return NT_STATUS_NOT_IMPLEMENTED;
    32893289}
    … …  
    32923292                                         struct lsa_SetTrustedDomainInfoByName *r)
    32933293{
    3294         p->rng_fault_state = True;
     3294        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    33143314                return NT_STATUS_NOT_IMPLEMENTED;
    33153315        }
    … …  
    33803380                                           struct lsa_QueryDomainInformationPolicy *r)
    33813381{
    3382         p->rng_fault_state = True;
     3382        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    33833383        return NT_STATUS_NOT_IMPLEMENTED;
    33843384}
    … …  
    33873387                                         struct lsa_SetDomainInformationPolicy *r)
    33883388{
    3389         p->rng_fault_state = True;
     3389        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34143414        return NT_STATUS_NOT_IMPLEMENTED;
    34153415}
    … …  
    34183418                                          struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
    34193419{
    3420         p->rng_fault_state = True;
     3420        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34213421        return NT_STATUS_NOT_IMPLEMENTED;
    34223422}
    … …  
    34253425                                         struct lsa_CREDRREADDOMAINCREDENTIALS *r)
    34263426{
    3427         p->rng_fault_state = True;
     3427        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34343434        return NT_STATUS_NOT_IMPLEMENTED;
    34353435}
    … …  
    34383438                                 struct lsa_CREDRGETTARGETINFO *r)
    34393439{
    3440         p->rng_fault_state = True;
     3440        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34413441        return NT_STATUS_NOT_IMPLEMENTED;
    34423442}
    … …  
    34453445                                 struct lsa_CREDRPROFILELOADED *r)
    34463446{
    3447         p->rng_fault_state = True;
     3447        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34483448        return NT_STATUS_NOT_IMPLEMENTED;
    34493449}
    … …  
    34523452                                   struct lsa_CREDRGETSESSIONTYPES *r)
    34533453{
    3454         p->rng_fault_state = True;
     3454        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34553455        return NT_STATUS_NOT_IMPLEMENTED;
    34563456}
    … …  
    34593459                                     struct lsa_LSARREGISTERAUDITEVENT *r)
    34603460{
    3461         p->rng_fault_state = True;
     3461        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34623462        return NT_STATUS_NOT_IMPLEMENTED;
    34633463}
    … …  
    34663466                                struct lsa_LSARGENAUDITEVENT *r)
    34673467{
    3468         p->rng_fault_state = True;
     3468        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34693469        return NT_STATUS_NOT_IMPLEMENTED;
    34703470}
    … …  
    34733473                                       struct lsa_LSARUNREGISTERAUDITEVENT *r)
    34743474{
    3475         p->rng_fault_state = True;
     3475        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34763476        return NT_STATUS_NOT_IMPLEMENTED;
    34773477}
    … …  
    34803480                                              struct lsa_lsaRQueryForestTrustInformation *r)
    34813481{
    3482         p->rng_fault_state = True;
     3482        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34833483        return NT_STATUS_NOT_IMPLEMENTED;
    34843484}
    … …  
    39933993                          struct lsa_CREDRRENAME *r)
    39943994{
    3995         p->rng_fault_state = True;
     3995        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    39963996        return NT_STATUS_NOT_IMPLEMENTED;
    39973997}
    … …  
    40004000                                struct lsa_LSAROPENPOLICYSCE *r)
    40014001{
    4002         p->rng_fault_state = True;
     4002        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    40034003        return NT_STATUS_NOT_IMPLEMENTED;
    40044004}
    … …  
    40074007                                                 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
    40084008{
    4009         p->rng_fault_state = True;
     4009        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    40104010        return NT_STATUS_NOT_IMPLEMENTED;
    40114011}
    … …  
    40144014                                                   struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
    40154015{
    4016         p->rng_fault_state = True;
     4016        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    40174017        return NT_STATUS_NOT_IMPLEMENTED;
    40184018}
    … …  
    40214021                                         struct lsa_LSARADTREPORTSECURITYEVENT *r)
    40224022{
    4023         p->rng_fault_state = True;
     4023        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    40244024        return NT_STATUS_NOT_IMPLEMENTED;
    40254025}

  • vendor/current/source3/rpc_server/netlogon/srv_netlog_nt.c

    r914 r919  
    15091509        {
    15101510                const char *wksname = nt_workstation;
     1511                const char *workgroup = lp_workgroup();
    15111512
    15121513                status = make_auth_context_fixed(talloc_tos(), &auth_context,
    … …  
    15331534                        status = NT_STATUS_NO_MEMORY;
    15341535                }
     1536
     1537                if (NT_STATUS_IS_OK(status)) {
     1538                        status = NTLMv2_RESPONSE_verify_netlogon_creds(
     1539                                                user_info->client.account_name,
     1540                                                user_info->client.domain_name,
     1541                                                user_info->password.response.nt,
     1542                                                creds, workgroup);
     1543                }
    15351544                break;
    15361545        }
    … …  
    16371646                break;
    16381647        case 6:
     1648                /* Only allow this if the pipe is protected. */
     1649                if (p->auth.auth_level < DCERPC_AUTH_LEVEL_PRIVACY) {
     1650                        DEBUG(0,("netr_Validation6: client %s not using privacy for netlogon\n",
     1651                                get_remote_machine_name()));
     1652                        status = NT_STATUS_INVALID_PARAMETER;
     1653                        break;
     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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    17911808        return WERR_NOT_SUPPORTED;
    17921809}
    … …  
    17981815                            struct netr_LogonUasLogoff *r)
    17991816{
    1800         p->rng_fault_state = true;
     1817        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18011818        return WERR_NOT_SUPPORTED;
    18021819}
    … …  
    18081825                              struct netr_DatabaseDeltas *r)
    18091826{
    1810         p->rng_fault_state = true;
     1827        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18111828        return NT_STATUS_NOT_IMPLEMENTED;
    18121829}
    … …  
    18181835                            struct netr_DatabaseSync *r)
    18191836{
    1820         p->rng_fault_state = true;
     1837        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18211838        return NT_STATUS_NOT_IMPLEMENTED;
    18221839}
    … …  
    18281845                             struct netr_AccountDeltas *r)
    18291846{
    1830         p->rng_fault_state = true;
     1847        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18311848        return NT_STATUS_NOT_IMPLEMENTED;
    18321849}
    … …  
    18381855                           struct netr_AccountSync *r)
    18391856{
    1840         p->rng_fault_state = true;
     1857        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18411858        return NT_STATUS_NOT_IMPLEMENTED;
    18421859}
    … …  
    19791996                             struct netr_DatabaseSync2 *r)
    19801997{
    1981         p->rng_fault_state = true;
     1998        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    19821999        return NT_STATUS_NOT_IMPLEMENTED;
    19832000}
    … …  
    19892006                            struct netr_DatabaseRedo *r)
    19902007{
    1991         p->rng_fault_state = true;
     2008        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    19922009        return NT_STATUS_NOT_IMPLEMENTED;
    19932010}
    … …  
    19992016                          struct netr_DsRGetDCName *r)
    20002017{
    2001         p->rng_fault_state = true;
     2018        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20022019        return WERR_NOT_SUPPORTED;
    20032020}
    … …  
    20182035                                     struct netr_NETRLOGONSETSERVICEBITS *r)
    20192036{
    2020         p->rng_fault_state = true;
     2037        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20212038        return WERR_NOT_SUPPORTED;
    20222039}
    … …  
    20282045                              struct netr_LogonGetTrustRid *r)
    20292046{
    2030         p->rng_fault_state = true;
     2047        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20312048        return WERR_NOT_SUPPORTED;
    20322049}
    … …  
    20382055                                          struct netr_NETRLOGONCOMPUTESERVERDIGEST *r)
    20392056{
    2040         p->rng_fault_state = true;
     2057        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20412058        return WERR_NOT_SUPPORTED;
    20422059}
    … …  
    20482065                                          struct netr_NETRLOGONCOMPUTECLIENTDIGEST *r)
    20492066{
    2050         p->rng_fault_state = true;
     2067        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20512068        return WERR_NOT_SUPPORTED;
    20522069}
    … …  
    20582075                            struct netr_DsRGetDCNameEx *r)
    20592076{
    2060         p->rng_fault_state = true;
     2077        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20612078        return WERR_NOT_SUPPORTED;
    20622079}
    … …  
    20682085                            struct netr_DsRGetSiteName *r)
    20692086{
    2070         p->rng_fault_state = true;
     2087        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20712088        return WERR_NOT_SUPPORTED;
    20722089}
    … …  
    20782095                                  struct netr_LogonGetDomainInfo *r)
    20792096{
    2080         p->rng_fault_state = true;
     2097        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20812098        return NT_STATUS_NOT_IMPLEMENTED;
    20822099}
    … …  
    20882105                               struct netr_ServerPasswordGet *r)
    20892106{
    2090         p->rng_fault_state = true;
     2107        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20912108        return WERR_NOT_SUPPORTED;
    20922109}
    … …  
    20982115                                struct netr_NETRLOGONSENDTOSAM *r)
    20992116{
    2100         p->rng_fault_state = true;
     2117        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21012118        return WERR_NOT_SUPPORTED;
    21022119}
    … …  
    21082125                                    struct netr_DsRAddressToSitenamesW *r)
    21092126{
    2110         p->rng_fault_state = true;
     2127        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21112128        return WERR_NOT_SUPPORTED;
    21122129}
    … …  
    21182135                             struct netr_DsRGetDCNameEx2 *r)
    21192136{
    2120         p->rng_fault_state = true;
     2137        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21212138        return WERR_NOT_SUPPORTED;
    21222139}
    … …  
    21282145                                                 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *r)
    21292146{
    2130         p->rng_fault_state = true;
     2147        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21312148        return WERR_NOT_SUPPORTED;
    21322149}
    … …  
    21382155                                           struct netr_NetrEnumerateTrustedDomainsEx *r)
    21392156{
    2140         p->rng_fault_state = true;
     2157        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21412158        return WERR_NOT_SUPPORTED;
    21422159}
    … …  
    21482165                                      struct netr_DsRAddressToSitenamesExW *r)
    21492166{
    2150         p->rng_fault_state = true;
     2167        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21512168        return WERR_NOT_SUPPORTED;
    21522169}
    … …  
    21582175                                   struct netr_DsrGetDcSiteCoverageW *r)
    21592176{
    2160         p->rng_fault_state = true;
     2177        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21612178        return WERR_NOT_SUPPORTED;
    21622179}
    … …  
    21682185                                      struct netr_DsrEnumerateDomainTrusts *r)
    21692186{
    2170         p->rng_fault_state = true;
     2187        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21712188        return WERR_NOT_SUPPORTED;
    21722189}
    … …  
    21782195                                         struct netr_DsrDeregisterDNSHostRecords *r)
    21792196{
    2180         p->rng_fault_state = true;
     2197        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21812198        return WERR_NOT_SUPPORTED;
    21822199}
    … …  
    21882205                                       struct netr_ServerTrustPasswordsGet *r)
    21892206{
    2190         p->rng_fault_state = true;
     2207        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21912208        return NT_STATUS_NOT_IMPLEMENTED;
    21922209}
    … …  
    21982215                                          struct netr_DsRGetForestTrustInformation *r)
    21992216{
    2200         p->rng_fault_state = true;
     2217        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    24802501        return NT_STATUS_NOT_IMPLEMENTED;
    24812502}
    … …  
    24872508                                                 struct netr_DsrUpdateReadOnlyServerDnsRecords *r)
    24882509{
    2489         p->rng_fault_state = true;
     2510        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    24902511        return NT_STATUS_NOT_IMPLEMENTED;
    24912512}

  • vendor/current/source3/rpc_server/ntsvcs/srv_ntsvcs_nt.c

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

  • vendor/current/source3/rpc_server/rpc_handles.c

    r917 r919  
    243243        dump_data(4, (uint8_t *)hnd, sizeof(*hnd));
    244244
    245         p->bad_handle_fault_state = true;
     245        p->fault_state = DCERPC_FAULT_CONTEXT_MISMATCH;
    246246
    247247        return NULL;

  • vendor/current/source3/rpc_server/rpc_ncacn_np.c

    r917 r919  
    172172        p->syntax = *syntax;
    173173        p->transport = NCALRPC;
     174        p->allow_bind = true;
    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        result->auth->auth_context_id = 0;
    794785
    795786        status = rpccli_anon_bind_data(result, &auth);

  • vendor/current/source3/rpc_server/rpc_server.c

    r740 r919  
    103103        p->transport = transport;
    104104        p->ncalrpc_as_system = ncalrpc_as_system;
     105        p->allow_bind = true;
    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                goto fail;
     665        }
     666
     667        if (npc->p->fault_state != 0) {
     668                DEBUG(2, ("Disconnect after fault\n"));
     669                sys_errno = EINVAL;
    663670                goto fail;
    664671        }
    … …  
    13921399        }
    13931400
     1401        if (ncacn_conn->p->fault_state != 0) {
     1402                DEBUG(2, ("Disconnect after fault\n"));
     1403                sys_errno = EINVAL;
     1404                goto fail;
     1405        }
     1406
    13941407        /* clear out any data that may have been left around */
    13951408        ncacn_conn->count = 0;

  • vendor/current/source3/rpc_server/samr/srv_samr_nt.c

    r860 r919  
    66296629        struct samr_PwInfo dom_pw_info;
    66306630
     6631        if (p->auth.auth_level != DCERPC_AUTH_LEVEL_PRIVACY) {
     6632                p->fault_state = DCERPC_FAULT_ACCESS_DENIED;
     6633                return NT_STATUS_ACCESS_DENIED;
     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->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    66866691        return NT_STATUS_NOT_IMPLEMENTED;
    66876692}
    … …  
    66936698                                          struct samr_SetMemberAttributesOfGroup *r)
    66946699{
    6695         p->rng_fault_state = true;
     6700        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    66966701        return NT_STATUS_NOT_IMPLEMENTED;
    66976702}
    … …  
    67036708                                          struct samr_TestPrivateFunctionsDomain *r)
    67046709{
     6710        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67056711        return NT_STATUS_NOT_IMPLEMENTED;
    67066712}
    … …  
    67126718                                        struct samr_TestPrivateFunctionsUser *r)
    67136719{
     6720        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67146721        return NT_STATUS_NOT_IMPLEMENTED;
    67156722}
    … …  
    67216728                                         struct samr_AddMultipleMembersToAlias *r)
    67226729{
    6723         p->rng_fault_state = true;
     6730        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67246731        return NT_STATUS_NOT_IMPLEMENTED;
    67256732}
    … …  
    67316738                                              struct samr_RemoveMultipleMembersFromAlias *r)
    67326739{
    6733         p->rng_fault_state = true;
     6740        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67346741        return NT_STATUS_NOT_IMPLEMENTED;
    67356742}
    … …  
    67416748                                     struct samr_SetBootKeyInformation *r)
    67426749{
    6743         p->rng_fault_state = true;
     6750        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67446751        return NT_STATUS_NOT_IMPLEMENTED;
    67456752}
    … …  
    67516758                                     struct samr_GetBootKeyInformation *r)
    67526759{
    6753         p->rng_fault_state = true;
     6760        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67546761        return NT_STATUS_NOT_IMPLEMENTED;
    67556762}
    … …  
    67616768                               struct samr_SetDsrmPassword *r)
    67626769{
    6763         p->rng_fault_state = true;
     6770        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67646771        return NT_STATUS_NOT_IMPLEMENTED;
    67656772}

  • vendor/current/source3/rpc_server/spoolss/srv_spoolss_nt.c

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

  • vendor/current/source3/rpc_server/srv_pipe.c

    r917 r919  
    4343#include "ntdomain.h"
    4444#include "rpc_server/srv_pipe.h"
     45#include "../librpc/gen_ndr/ndr_dcerpc.h"
     46#include "../librpc/ndr/ndr_dcerpc.h"
     47#include "../librpc/gen_ndr/ndr_samr.h"
     48#include "../librpc/gen_ndr/ndr_lsa.h"
     49#include "../librpc/gen_ndr/ndr_netlogon.h"
     50#include "../librpc/gen_ndr/ndr_epmapper.h"
     51#include "../librpc/gen_ndr/ndr_echo.h"
    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(p->fault_state));
    206213                return true;
    207214        }
    … …  
    270277        p->out_data.current_pdu_sent = 0;
    271278
     279        set_incoming_fault(p);
    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        p->allow_bind = false;
     285        p->allow_alter = false;
     286        p->allow_auth3 = false;
    276287
    277288        return True;
    … …  
    335346{
    336347        struct pipe_rpc_fns *context_fns;
     348        const char *interface_name = NULL;
     349        bool ok;
    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        DEBUG(3, ("check_bind_req: %s -> %s rpc service\n",
     391                  rpc_srv_get_pipe_cli_name(abstract),
     392                  rpc_srv_get_pipe_srv_name(abstract)));
    350393
    351394        context_fns = SMB_MALLOC_P(struct pipe_rpc_fns);
    … …  
    355398        }
    356399
     400        interface_name = get_pipe_name_from_syntax(talloc_tos(),
     401                                                   abstract);
     402
     403        SMB_ASSERT(interface_name != NULL);
     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        context_fns->syntax = *abstract;
     410
     411        context_fns->allow_connect = lp_allow_dcerpc_auth_level_connect();
     412        /*
     413         * for the samr and the lsarpc interfaces we don't allow "connect"
     414         * auth_level by default.
     415         */
     416        ok = ndr_syntax_id_equal(abstract, &ndr_table_samr.syntax_id);
     417        if (ok) {
     418                context_fns->allow_connect = false;
     419        }
     420        ok = ndr_syntax_id_equal(abstract, &ndr_table_lsarpc.syntax_id);
     421        if (ok) {
     422                context_fns->allow_connect = false;
     423        }
     424        ok = ndr_syntax_id_equal(abstract, &ndr_table_netlogon.syntax_id);
     425        if (ok) {
     426                context_fns->allow_connect = false;
     427        }
     428        /*
     429         * for the epmapper and echo interfaces we allow "connect"
     430         * auth_level by default.
     431         */
     432        ok = ndr_syntax_id_equal(abstract, &ndr_table_epmapper.syntax_id);
     433        if (ok) {
     434                context_fns->allow_connect = true;
     435        }
     436        ok = ndr_syntax_id_equal(abstract, &ndr_table_rpcecho.syntax_id);
     437        if (ok) {
     438                context_fns->allow_connect = true;
     439        }
     440        /*
     441         * every interface can be modified to allow "connect" auth_level by
     442         * using a parametric option like:
     443         * allow dcerpc auth level connect:<interface>
     444         * e.g.
     445         * allow dcerpc auth level connect:samr = yes
     446         */
     447        context_fns->allow_connect = lp_parm_bool(-1,
     448                "allow dcerpc auth level connect",
     449                interface_name, context_fns->allow_connect);
    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        p->auth.auth_context_id = auth_info->auth_context_id;
    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        p->auth.auth_context_id = auth_info->auth_context_id;
    558649
    559650        p->pipe_bound = True;
    … …  
    600691        p->auth.auth_ctx = ntlmssp_state;
    601692        p->auth.auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
     693        p->auth.auth_context_id = auth_info->auth_context_id;
    602694
    603695        DEBUG(10, (__location__ ": NTLMSSP auth started\n"));
    … …  
    774866        void *mech_ctx;
    775867        NTSTATUS status;
     868
     869        if (p->auth.auth_type == DCERPC_AUTH_TYPE_NONE) {
     870                p->pipe_bound = true;
     871                return NT_STATUS_OK;
     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        p->allow_bind = false;
     970
     971        status = dcerpc_verify_ncacn_packet_header(pkt,
     972                        DCERPC_PKT_BIND,
     973                        pkt->u.bind.auth_info.length,
     974                        0, /* required flags */
     975                        DCERPC_PFC_FLAG_FIRST |
     976                        DCERPC_PFC_FLAG_LAST |
     977                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
     978                        0x08 | /* this is not defined, but should be ignored */
     979                        DCERPC_PFC_FLAG_CONC_MPX |
     980                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
     981                        DCERPC_PFC_FLAG_MAYBE |
     982                        DCERPC_PFC_FLAG_OBJECT_UUID);
     983        if (!NT_STATUS_IS_OK(status)) {
     984                DEBUG(1, ("api_pipe_bind_req: invalid pdu: %s\n",
     985                          nt_errstr(status)));
     986                NDR_PRINT_DEBUG(ncacn_packet, pkt);
     987                goto err_exit;
     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_auth_trailer(pkt, pkt,
     1084                                                  &pkt->u.bind.auth_info,
     1085                                                  &auth_info, NULL, true);
    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                p->auth.auth_context_id = 0;
    10731180        }
    10741181
    … …  
    11121219                DEBUG(0, ("Failed to marshall bind_ack packet. (%s)\n",
    11131220                          nt_errstr(status)));
     1221                goto err_exit;
    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, /* pad_len */
     1229                                                 p->auth.auth_context_id,
    11231230                                                 &auth_resp,
    11241231                                                 &auth_blob);
    … …  
    11511258
    11521259        TALLOC_FREE(auth_blob.data);
     1260
     1261        if (bind_ack_ctx.result == 0) {
     1262                p->allow_alter = true;
     1263                p->allow_auth3 = true;
     1264                if (p->auth.auth_type == DCERPC_AUTH_TYPE_NONE) {
     1265                        status = pipe_auth_verify_final(p);
     1266                        if (!NT_STATUS_IS_OK(status)) {
     1267                                DEBUG(0, ("pipe_auth_verify_final failed: %s\n",
     1268                                          nt_errstr(status)));
     1269                                goto err_exit;
     1270                        }
     1271                }
     1272        } else {
     1273                goto err_exit;
     1274        }
     1275
    11531276        return True;
    11541277
    … …  
    11751298        DEBUG(5, ("api_pipe_bind_auth3: decode request. %d\n", __LINE__));
    11761299
     1300        if (!p->allow_auth3) {
     1301                DEBUG(1, ("Pipe not in allow auth3 state.\n"));
     1302                goto err;
     1303        }
     1304
     1305        status = dcerpc_verify_ncacn_packet_header(pkt,
     1306                        DCERPC_PKT_AUTH3,
     1307                        pkt->u.auth3.auth_info.length,
     1308                        0, /* required flags */
     1309                        DCERPC_PFC_FLAG_FIRST |
     1310                        DCERPC_PFC_FLAG_LAST |
     1311                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
     1312                        0x08 | /* this is not defined, but should be ignored */
     1313                        DCERPC_PFC_FLAG_CONC_MPX |
     1314                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
     1315                        DCERPC_PFC_FLAG_MAYBE |
     1316                        DCERPC_PFC_FLAG_OBJECT_UUID);
     1317        if (!NT_STATUS_IS_OK(status)) {
     1318                DEBUG(1, ("api_pipe_bind_auth3: invalid pdu: %s\n",
     1319                          nt_errstr(status)));
     1320                NDR_PRINT_DEBUG(ncacn_packet, pkt);
     1321                goto err;
     1322        }
     1323
     1324        /* We can only finish if the pipe is unbound for now */
     1325        if (p->pipe_bound) {
     1326                DEBUG(0, (__location__ ": Pipe already bound, "
     1327                          "AUTH3 not supported!\n"));
     1328                goto err;
     1329        }
     1330
    11771331        if (pkt->auth_length == 0) {
    1178                 DEBUG(0, ("No auth field sent for bind request!\n"));
     1332                DEBUG(1, ("No auth field sent for auth3 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_auth_trailer(pkt, pkt,
     1341                                          &pkt->u.auth3.auth_info,
     1342                                          &auth_info, NULL, true);
    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                goto err;
     1358        }
     1359
     1360        if (auth_info.auth_level != p->auth.auth_level) {
     1361                DEBUG(1, ("Auth level mismatch! Client sent %d, "
     1362                          "but auth was started as level %d!\n",
     1363                          auth_info.auth_level, p->auth.auth_level));
     1364                goto err;
     1365        }
     1366
     1367        if (auth_info.auth_context_id != p->auth.auth_context_id) {
     1368                DEBUG(0, ("Auth context id mismatch! Client sent %u, "
     1369                          "but auth was started as level %u!\n",
     1370                          (unsigned)auth_info.auth_context_id,
     1371                          (unsigned)p->auth.auth_context_id));
    12131372                goto err;
    12141373        }
    … …  
    12661425
    12671426err:
     1427        p->pipe_bound = false;
     1428        p->allow_bind = false;
     1429        p->allow_alter = false;
     1430        p->allow_auth3 = false;
    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 alter_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 alter_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.alter.ctx_list[0].abstract_syntax,
     1510                        &pkt->u.alter.ctx_list[0].transfer_syntaxes[0],
     1511                        pkt->u.alter.ctx_list[0].context_id)) {
     1512
     1513                alter_ack_ctx.result = 0;
     1514                alter_ack_ctx.reason = 0;
     1515                alter_ack_ctx.syntax = pkt->u.alter.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                alter_ack_ctx.result = DCERPC_BIND_PROVIDER_REJECT;
     1519                alter_ack_ctx.reason = DCERPC_BIND_REASON_ASYNTAX;
     1520                alter_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                status = dcerpc_pull_auth_trailer(pkt, pkt,
     1535                                                  &pkt->u.alter.auth_info,
     1536                                                  &auth_info, NULL, true);
     1537                if (!NT_STATUS_IS_OK(status)) {
     1538                        DEBUG(0, ("Unable to unmarshall dcerpc_auth.\n"));
     1539                        goto err_exit;
     1540                }
     1541
    13591542                if (auth_info.auth_type != p->auth.auth_type) {
    13601543                        DEBUG(0, ("Auth type mismatch! Client sent %d, "
    … …  
    13641547                }
    13651548
     1549                if (auth_info.auth_level != p->auth.auth_level) {
     1550                        DEBUG(0, ("Auth level mismatch! Client sent %d, "
     1551                                  "but auth was started as level %d!\n",
     1552                                  auth_info.auth_level, p->auth.auth_level));
     1553                        goto err_exit;
     1554                }
     1555
     1556                if (auth_info.auth_context_id != p->auth.auth_context_id) {
     1557                        DEBUG(0, ("Auth context id mismatch! Client sent %u, "
     1558                                  "but auth was started as level %u!\n",
     1559                                  (unsigned)auth_info.auth_context_id,
     1560                                  (unsigned)p->auth.auth_context_id));
     1561                        goto err_exit;
     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 = &alter_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 alter_resp packet. (%s)\n",
    14531650                          nt_errstr(status)));
     1651                goto err_exit;
    14541652        }
    14551653
    … …  
    14681666                                                 auth_info.auth_level,
    14691667                                                 pad_len,
    1470                                                  1, /* auth_context_id */
     1668                                                 p->auth.auth_context_id,
    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        TALLOC_CTX *frame = talloc_stackframe();
    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         * We don't ignore DCERPC_PFC_FLAG_PENDING_CANCEL.
     2036         * TODO: we can reject it with DCERPC_FAULT_NO_CALL_ACTIVE later.
     2037         */
     2038        status = dcerpc_verify_ncacn_packet_header(pkt,
     2039                        DCERPC_PKT_REQUEST,
     2040                        pkt->u.request.stub_and_verifier.length,
     2041                        0, /* required_flags */
     2042                        DCERPC_PFC_FLAG_FIRST |
     2043                        DCERPC_PFC_FLAG_LAST |
     2044                        0x08 | /* this is not defined, but should be ignored */
     2045                        DCERPC_PFC_FLAG_CONC_MPX |
     2046                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
     2047                        DCERPC_PFC_FLAG_MAYBE |
     2048                        DCERPC_PFC_FLAG_OBJECT_UUID);
     2049        if (!NT_STATUS_IS_OK(status)) {
     2050                DEBUG(1, ("process_request_pdu: invalid pdu: %s\n",
     2051                          nt_errstr(status)));
     2052                NDR_PRINT_DEBUG(ncacn_packet, pkt);
     2053                set_incoming_fault(p);
     2054                return false;
    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_NCA_S_PROTO_ERROR));
    20312307                TALLOC_FREE(pkt);
    20322308        } else {

  • vendor/current/source3/rpc_server/srvsvc/srv_srvsvc_nt.c

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

  • vendor/current/source3/rpc_server/svcctl/srv_svcctl_nt.c

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

  • vendor/current/source3/rpc_server/winreg/srv_winreg_nt.c

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

  • vendor/current/source3/rpc_server/wkssvc/srv_wkssvc_nt.c

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