groupdb/mapping.h

ソースコードを見る。

関数

BOOL enum_group_mapping (const DOM_SID *domsid, enum lsa_SidType sid_name_use, GROUP_MAP **pp_rmap, size_t *p_num_entries, BOOL unix_only)
BOOL group_map_remove (const DOM_SID *sid)
BOOL init_group_mapping (void)
NTSTATUS one_alias_membership (const DOM_SID *member, DOM_SID **sids, size_t *num)
BOOL get_group_map_from_sid (DOM_SID sid, GROUP_MAP *map)
BOOL get_group_map_from_gid (gid_t gid, GROUP_MAP *map)
BOOL get_group_map_from_ntname (const char *name, GROUP_MAP *map)
BOOL add_mapping_entry (GROUP_MAP *map, int flag)
NTSTATUS add_aliasmem (const DOM_SID *alias, const DOM_SID *member)
NTSTATUS del_aliasmem (const DOM_SID *alias, const DOM_SID *member)
NTSTATUS enum_aliasmem (const DOM_SID *alias, DOM_SID **sids, size_t *num)


関数

BOOL enum_group_mapping ( const DOM_SID domsid,
enum lsa_SidType  sid_name_use,
GROUP_MAP **  pp_rmap,
size_t *  p_num_entries,
BOOL  unix_only 
)

mapping_tdb.c302 行で定義されています。

参照先 _GROUP_MAP::commentTDB_DATA::dptrTDB_DATA::dsize_GROUP_MAP::gidinit_group_mapping()_GROUP_MAP::nt_namesafe_free()_GROUP_MAP::sidsid_copy()sid_equal()SID_NAME_UNKNOWN_GROUP_MAP::sid_name_usesid_split_rid()sid_string_static()sid_type_lookup()string_to_sid()tdbtdb_fetch()tdb_firstkey()tdb_nextkey()tdb_unpack().

参照元 init_group_mapping()pdb_default_enum_group_mapping()pdb_enum_group_mapping().

00304 {
00305         TDB_DATA kbuf, dbuf, newkey;
00306         fstring string_sid;
00307         GROUP_MAP map;
00308         GROUP_MAP *mapt;
00309         int ret;
00310         size_t entries=0;
00311         DOM_SID grpsid;
00312         uint32 rid;
00313 
00314         if(!init_group_mapping()) {
00315                 DEBUG(0,("failed to initialize group mapping\n"));
00316                 return(False);
00317         }
00318 
00319         *p_num_entries=0;
00320         *pp_rmap=NULL;
00321 
00322         for (kbuf = tdb_firstkey(tdb); 
00323              kbuf.dptr; 
00324              newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
00325 
00326                 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0)
00327                         continue;
00328 
00329                 dbuf = tdb_fetch(tdb, kbuf);
00330                 if (!dbuf.dptr)
00331                         continue;
00332 
00333                 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
00334                                 
00335                 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
00336                                  &map.gid, &map.sid_name_use, &map.nt_name, &map.comment);
00337 
00338                 SAFE_FREE(dbuf.dptr);
00339 
00340                 if ( ret == -1 ) {
00341                         DEBUG(3,("enum_group_mapping: tdb_unpack failure\n"));
00342                         continue;
00343                 }
00344         
00345                 /* list only the type or everything if UNKNOWN */
00346                 if (sid_name_use!=SID_NAME_UNKNOWN  && sid_name_use!=map.sid_name_use) {
00347                         DEBUG(11,("enum_group_mapping: group %s is not of the requested type\n", map.nt_name));
00348                         continue;
00349                 }
00350 
00351                 if (unix_only==ENUM_ONLY_MAPPED && map.gid==-1) {
00352                         DEBUG(11,("enum_group_mapping: group %s is non mapped\n", map.nt_name));
00353                         continue;
00354                 }
00355 
00356                 string_to_sid(&grpsid, string_sid);
00357                 sid_copy( &map.sid, &grpsid );
00358                 
00359                 sid_split_rid( &grpsid, &rid );
00360 
00361                 /* Only check the domain if we were given one */
00362 
00363                 if ( domsid && !sid_equal( domsid, &grpsid ) ) {
00364                         DEBUG(11,("enum_group_mapping: group %s is not in domain %s\n", 
00365                                 string_sid, sid_string_static(domsid)));
00366                         continue;
00367                 }
00368 
00369                 DEBUG(11,("enum_group_mapping: returning group %s of "
00370                           "type %s\n", map.nt_name,
00371                           sid_type_lookup(map.sid_name_use)));
00372 
00373                 (*pp_rmap) = SMB_REALLOC_ARRAY((*pp_rmap), GROUP_MAP, entries+1);
00374                 if (!(*pp_rmap)) {
00375                         DEBUG(0,("enum_group_mapping: Unable to enlarge group map!\n"));
00376                         return False;
00377                 }
00378 
00379                 mapt = (*pp_rmap);
00380 
00381                 mapt[entries].gid = map.gid;
00382                 sid_copy( &mapt[entries].sid, &map.sid);
00383                 mapt[entries].sid_name_use = map.sid_name_use;
00384                 fstrcpy(mapt[entries].nt_name, map.nt_name);
00385                 fstrcpy(mapt[entries].comment, map.comment);
00386 
00387                 entries++;
00388 
00389         }
00390 
00391         *p_num_entries=entries;
00392 
00393         return True;
00394 }

BOOL group_map_remove ( const DOM_SID sid  ) 

mapping_tdb.c267 行で定義されています。

参照先 TDB_DATA::dptrTDB_DATA::dsizeinit_group_mapping()sid_to_string()tdbtdb_delete()tdb_fetch()TDB_SUCCESS.

参照元 init_group_mapping()pdb_default_delete_group_mapping_entry().

00268 {
00269         TDB_DATA kbuf, dbuf;
00270         pstring key;
00271         fstring string_sid;
00272         
00273         if(!init_group_mapping()) {
00274                 DEBUG(0,("failed to initialize group mapping\n"));
00275                 return(False);
00276         }
00277 
00278         /* the key is the SID, retrieving is direct */
00279 
00280         sid_to_string(string_sid, sid);
00281         slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
00282 
00283         kbuf.dptr = key;
00284         kbuf.dsize = strlen(key)+1;
00285                 
00286         dbuf = tdb_fetch(tdb, kbuf);
00287         if (!dbuf.dptr)
00288                 return False;
00289         
00290         SAFE_FREE(dbuf.dptr);
00291 
00292         if(tdb_delete(tdb, kbuf) != TDB_SUCCESS)
00293                 return False;
00294 
00295         return True;
00296 }

BOOL init_group_mapping ( void   ) 

mapping_tdb.c32 行で定義されています。

参照先 enum_group_mapping()group_map_remove()lock_path()SID_NAME_UNKNOWNtdbtdb_fetch_int32()tdb_lock_bystring()tdb_open_log()tdb_store_int32()tdb_traverse()tdb_traverse_delete_fn()tdb_unlock_bystring().

参照元 add_aliasmem()add_initial_entry()add_mapping_entry()enum_aliasmem()enum_group_mapping()get_domain_group_from_sid()get_group_map_from_gid()get_group_map_from_ntname()get_group_map_from_sid()group_map_remove()one_alias_membership().

00033 {
00034         const char *vstring = "INFO/version";
00035         int32 vers_id;
00036         GROUP_MAP *map_table = NULL;
00037         size_t num_entries = 0;
00038         
00039         if (tdb)
00040                 return True;
00041                 
00042         tdb = tdb_open_log(lock_path("group_mapping.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
00043         if (!tdb) {
00044                 DEBUG(0,("Failed to open group mapping database\n"));
00045                 return False;
00046         }
00047 
00048         /* handle a Samba upgrade */
00049         tdb_lock_bystring(tdb, vstring);
00050 
00051         /* Cope with byte-reversed older versions of the db. */
00052         vers_id = tdb_fetch_int32(tdb, vstring);
00053         if ((vers_id == DATABASE_VERSION_V1) || (IREV(vers_id) == DATABASE_VERSION_V1)) {
00054                 /* Written on a bigendian machine with old fetch_int code. Save as le. */
00055                 tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
00056                 vers_id = DATABASE_VERSION_V2;
00057         }
00058 
00059         /* if its an unknown version we remove everthing in the db */
00060         
00061         if (vers_id != DATABASE_VERSION_V2) {
00062                 tdb_traverse(tdb, tdb_traverse_delete_fn, NULL);
00063                 tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
00064         }
00065 
00066         tdb_unlock_bystring(tdb, vstring);
00067 
00068         /* cleanup any map entries with a gid == -1 */
00069         
00070         if ( enum_group_mapping( NULL, SID_NAME_UNKNOWN, &map_table, &num_entries, False ) ) {
00071                 int i;
00072                 
00073                 for ( i=0; i<num_entries; i++ ) {
00074                         if ( map_table[i].gid == -1 ) {
00075                                 group_map_remove( &map_table[i].sid );
00076                         }
00077                 }
00078                 
00079                 SAFE_FREE( map_table );
00080         }
00081 
00082 
00083         return True;
00084 }

NTSTATUS one_alias_membership ( const DOM_SID member,
DOM_SID **  sids,
size_t *  num 
)

mapping_tdb.c399 行で定義されています。

参照先 add_sid_to_array_unique()TDB_DATA::dptrTDB_DATA::dsizeinit_group_mapping()next_token()sid_to_string()string_to_sid()tdbtdb_fetch().

参照元 alias_memberships().

00401 {
00402         fstring key, string_sid;
00403         TDB_DATA kbuf, dbuf;
00404         const char *p;
00405 
00406         if (!init_group_mapping()) {
00407                 DEBUG(0,("failed to initialize group mapping\n"));
00408                 return NT_STATUS_ACCESS_DENIED;
00409         }
00410 
00411         sid_to_string(string_sid, member);
00412         slprintf(key, sizeof(key), "%s%s", MEMBEROF_PREFIX, string_sid);
00413 
00414         kbuf.dsize = strlen(key)+1;
00415         kbuf.dptr = key;
00416 
00417         dbuf = tdb_fetch(tdb, kbuf);
00418 
00419         if (dbuf.dptr == NULL) {
00420                 return NT_STATUS_OK;
00421         }
00422 
00423         p = dbuf.dptr;
00424 
00425         while (next_token(&p, string_sid, " ", sizeof(string_sid))) {
00426 
00427                 DOM_SID alias;
00428 
00429                 if (!string_to_sid(&alias, string_sid))
00430                         continue;
00431 
00432                 if (!add_sid_to_array_unique(NULL, &alias, sids, num)) {
00433                         return NT_STATUS_NO_MEMORY;
00434                 }
00435         }
00436 
00437         SAFE_FREE(dbuf.dptr);
00438         return NT_STATUS_OK;
00439 }

BOOL get_group_map_from_sid ( DOM_SID  sid,
GROUP_MAP map 
)

mapping_tdb.c124 行で定義されています。

参照先 _GROUP_MAP::commentTDB_DATA::dptrTDB_DATA::dsize_GROUP_MAP::gidinit_group_mapping()_GROUP_MAP::nt_name_GROUP_MAP::sidsid_copy()_GROUP_MAP::sid_name_usesid_to_string()tdbtdb_fetch()tdb_unpack().

参照元 add_aliasmem()enum_aliasmem()pdb_default_getgrsid().

00125 {
00126         TDB_DATA kbuf, dbuf;
00127         pstring key;
00128         fstring string_sid;
00129         int ret = 0;
00130         
00131         if(!init_group_mapping()) {
00132                 DEBUG(0,("failed to initialize group mapping\n"));
00133                 return(False);
00134         }
00135 
00136         /* the key is the SID, retrieving is direct */
00137 
00138         sid_to_string(string_sid, &sid);
00139         slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
00140 
00141         kbuf.dptr = key;
00142         kbuf.dsize = strlen(key)+1;
00143                 
00144         dbuf = tdb_fetch(tdb, kbuf);
00145         if (!dbuf.dptr)
00146                 return False;
00147 
00148         ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
00149                                 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
00150 
00151         SAFE_FREE(dbuf.dptr);
00152         
00153         if ( ret == -1 ) {
00154                 DEBUG(3,("get_group_map_from_sid: tdb_unpack failure\n"));
00155                 return False;
00156         }
00157 
00158         sid_copy(&map->sid, &sid);
00159         
00160         return True;
00161 }

BOOL get_group_map_from_gid ( gid_t  gid,
GROUP_MAP map 
)

mapping_tdb.c167 行で定義されています。

参照先 _GROUP_MAP::commentTDB_DATA::dptrTDB_DATA::dsize_GROUP_MAP::gidinit_group_mapping()_GROUP_MAP::nt_namesafe_free()_GROUP_MAP::sid_GROUP_MAP::sid_name_usestring_to_sid()tdbtdb_fetch()tdb_firstkey()tdb_nextkey()tdb_unpack().

参照元 pdb_default_getgrgid().

00168 {
00169         TDB_DATA kbuf, dbuf, newkey;
00170         fstring string_sid;
00171         int ret;
00172 
00173         if(!init_group_mapping()) {
00174                 DEBUG(0,("failed to initialize group mapping\n"));
00175                 return(False);
00176         }
00177 
00178         /* we need to enumerate the TDB to find the GID */
00179 
00180         for (kbuf = tdb_firstkey(tdb); 
00181              kbuf.dptr; 
00182              newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
00183 
00184                 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
00185                 
00186                 dbuf = tdb_fetch(tdb, kbuf);
00187                 if (!dbuf.dptr)
00188                         continue;
00189 
00190                 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
00191 
00192                 string_to_sid(&map->sid, string_sid);
00193                 
00194                 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
00195                                  &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
00196 
00197                 SAFE_FREE(dbuf.dptr);
00198 
00199                 if ( ret == -1 ) {
00200                         DEBUG(3,("get_group_map_from_gid: tdb_unpack failure\n"));
00201                         return False;
00202                 }
00203         
00204                 if (gid==map->gid) {
00205                         SAFE_FREE(kbuf.dptr);
00206                         return True;
00207                 }
00208         }
00209 
00210         return False;
00211 }

BOOL get_group_map_from_ntname ( const char *  name,
GROUP_MAP map 
)

mapping_tdb.c217 行で定義されています。

参照先 _GROUP_MAP::commentTDB_DATA::dptrTDB_DATA::dsize_GROUP_MAP::gidinit_group_mapping()_GROUP_MAP::nt_namesafe_free()_GROUP_MAP::sid_GROUP_MAP::sid_name_usestrequal()string_to_sid()tdbtdb_fetch()tdb_firstkey()tdb_nextkey()tdb_unpack().

参照元 pdb_default_getgrnam().

00218 {
00219         TDB_DATA kbuf, dbuf, newkey;
00220         fstring string_sid;
00221         int ret;
00222 
00223         if(!init_group_mapping()) {
00224                 DEBUG(0,("get_group_map_from_ntname:failed to initialize group mapping\n"));
00225                 return(False);
00226         }
00227 
00228         /* we need to enumerate the TDB to find the name */
00229 
00230         for (kbuf = tdb_firstkey(tdb); 
00231              kbuf.dptr; 
00232              newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
00233 
00234                 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
00235                 
00236                 dbuf = tdb_fetch(tdb, kbuf);
00237                 if (!dbuf.dptr)
00238                         continue;
00239 
00240                 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
00241 
00242                 string_to_sid(&map->sid, string_sid);
00243                 
00244                 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
00245                                  &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
00246 
00247                 SAFE_FREE(dbuf.dptr);
00248                 
00249                 if ( ret == -1 ) {
00250                         DEBUG(3,("get_group_map_from_ntname: tdb_unpack failure\n"));
00251                         return False;
00252                 }
00253 
00254                 if ( strequal(name, map->nt_name) ) {
00255                         SAFE_FREE(kbuf.dptr);
00256                         return True;
00257                 }
00258         }
00259 
00260         return False;
00261 }

BOOL add_mapping_entry ( GROUP_MAP map,
int  flag 
)

mapping_tdb.c88 行で定義されています。

参照先 buf_GROUP_MAP::commentTDB_DATA::dptrTDB_DATA::dsize_GROUP_MAP::gidinit_group_mapping()len_GROUP_MAP::nt_name_GROUP_MAP::sid_GROUP_MAP::sid_name_usesid_to_string()tdbtdb_pack()tdb_store().

参照元 pdb_default_add_group_mapping_entry()pdb_default_update_group_mapping_entry().

00089 {
00090         TDB_DATA kbuf, dbuf;
00091         pstring key, buf;
00092         fstring string_sid="";
00093         int len;
00094 
00095         if(!init_group_mapping()) {
00096                 DEBUG(0,("failed to initialize group mapping\n"));
00097                 return(False);
00098         }
00099         
00100         sid_to_string(string_sid, &map->sid);
00101 
00102         len = tdb_pack(buf, sizeof(buf), "ddff",
00103                         map->gid, map->sid_name_use, map->nt_name, map->comment);
00104 
00105         if (len > sizeof(buf))
00106                 return False;
00107 
00108         slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
00109 
00110         kbuf.dsize = strlen(key)+1;
00111         kbuf.dptr = key;
00112         dbuf.dsize = len;
00113         dbuf.dptr = buf;
00114         if (tdb_store(tdb, kbuf, dbuf, flag) != 0) return False;
00115 
00116         return True;
00117 }

NTSTATUS add_aliasmem ( const DOM_SID alias,
const DOM_SID member 
)

mapping_tdb.c478 行で定義されています。

参照先 asprintf()TDB_DATA::dptrTDB_DATA::dsizeget_group_map_from_sid()init_group_mapping()is_aliasmem()resultSID_NAME_ALIAS_GROUP_MAP::sid_name_useSID_NAME_WKN_GRPsid_to_string()tdbtdb_fetch()tdb_store().

参照元 pdb_default_add_aliasmem().

00479 {
00480         GROUP_MAP map;
00481         TDB_DATA kbuf, dbuf;
00482         pstring key;
00483         fstring string_sid;
00484         char *new_memberstring;
00485         int result;
00486 
00487         if(!init_group_mapping()) {
00488                 DEBUG(0,("failed to initialize group mapping\n"));
00489                 return NT_STATUS_ACCESS_DENIED;
00490         }
00491 
00492         if (!get_group_map_from_sid(*alias, &map))
00493                 return NT_STATUS_NO_SUCH_ALIAS;
00494 
00495         if ( (map.sid_name_use != SID_NAME_ALIAS) &&
00496              (map.sid_name_use != SID_NAME_WKN_GRP) )
00497                 return NT_STATUS_NO_SUCH_ALIAS;
00498 
00499         if (is_aliasmem(alias, member))
00500                 return NT_STATUS_MEMBER_IN_ALIAS;
00501 
00502         sid_to_string(string_sid, member);
00503         slprintf(key, sizeof(key), "%s%s", MEMBEROF_PREFIX, string_sid);
00504 
00505         kbuf.dsize = strlen(key)+1;
00506         kbuf.dptr = key;
00507 
00508         dbuf = tdb_fetch(tdb, kbuf);
00509 
00510         sid_to_string(string_sid, alias);
00511 
00512         if (dbuf.dptr != NULL) {
00513                 asprintf(&new_memberstring, "%s %s", (char *)(dbuf.dptr),
00514                          string_sid);
00515         } else {
00516                 new_memberstring = SMB_STRDUP(string_sid);
00517         }
00518 
00519         if (new_memberstring == NULL)
00520                 return NT_STATUS_NO_MEMORY;
00521 
00522         SAFE_FREE(dbuf.dptr);
00523         dbuf.dsize = strlen(new_memberstring)+1;
00524         dbuf.dptr = new_memberstring;
00525 
00526         result = tdb_store(tdb, kbuf, dbuf, 0);
00527 
00528         SAFE_FREE(new_memberstring);
00529 
00530         return (result == 0 ? NT_STATUS_OK : NT_STATUS_ACCESS_DENIED);
00531 }

NTSTATUS del_aliasmem ( const DOM_SID alias,
const DOM_SID member 
)

mapping_tdb.c616 行で定義されています。

参照先 aliasmem_closure::aliasalias_memberships()asprintf()TDB_DATA::dptrTDB_DATA::dsizealiasmem_closure::numresultsid_compare()sid_to_string()aliasmem_closure::sidstdbtdb_delete()tdb_store().

参照元 pdb_default_del_aliasmem().

00617 {
00618         NTSTATUS result;
00619         DOM_SID *sids;
00620         size_t i, num;
00621         BOOL found = False;
00622         char *member_string;
00623         TDB_DATA kbuf, dbuf;
00624         pstring key;
00625         fstring sid_string;
00626 
00627         result = alias_memberships(member, 1, &sids, &num);
00628 
00629         if (!NT_STATUS_IS_OK(result))
00630                 return result;
00631 
00632         for (i=0; i<num; i++) {
00633                 if (sid_compare(&sids[i], alias) == 0) {
00634                         found = True;
00635                         break;
00636                 }
00637         }
00638 
00639         if (!found) {
00640                 TALLOC_FREE(sids);
00641                 return NT_STATUS_MEMBER_NOT_IN_ALIAS;
00642         }
00643 
00644         if (i < num)
00645                 sids[i] = sids[num-1];
00646 
00647         num -= 1;
00648 
00649         sid_to_string(sid_string, member);
00650         slprintf(key, sizeof(key), "%s%s", MEMBEROF_PREFIX, sid_string);
00651 
00652         kbuf.dsize = strlen(key)+1;
00653         kbuf.dptr = key;
00654 
00655         if (num == 0)
00656                 return tdb_delete(tdb, kbuf) == 0 ?
00657                         NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
00658 
00659         member_string = SMB_STRDUP("");
00660 
00661         if (member_string == NULL) {
00662                 TALLOC_FREE(sids);
00663                 return NT_STATUS_NO_MEMORY;
00664         }
00665 
00666         for (i=0; i<num; i++) {
00667                 char *s = member_string;
00668 
00669                 sid_to_string(sid_string, &sids[i]);
00670                 asprintf(&member_string, "%s %s", s, sid_string);
00671 
00672                 SAFE_FREE(s);
00673                 if (member_string == NULL) {
00674                         TALLOC_FREE(sids);
00675                         return NT_STATUS_NO_MEMORY;
00676                 }
00677         }
00678 
00679         dbuf.dsize = strlen(member_string)+1;
00680         dbuf.dptr = member_string;
00681 
00682         result = tdb_store(tdb, kbuf, dbuf, 0) == 0 ?
00683                 NT_STATUS_OK : NT_STATUS_ACCESS_DENIED;
00684 
00685         TALLOC_FREE(sids);
00686         SAFE_FREE(member_string);
00687 
00688         return result;
00689 }

NTSTATUS enum_aliasmem ( const DOM_SID alias,
DOM_SID **  sids,
size_t *  num 
)

mapping_tdb.c588 行で定義されています。

参照先 aliasmem_closure::aliascollect_aliasmem()get_group_map_from_sid()init_group_mapping()aliasmem_closure::numSID_NAME_ALIAS_GROUP_MAP::sid_name_useSID_NAME_WKN_GRPaliasmem_closure::sidstdbtdb_traverse().

参照元 pdb_default_enum_aliasmem().

00589 {
00590         GROUP_MAP map;
00591         struct aliasmem_closure closure;
00592 
00593         if(!init_group_mapping()) {
00594                 DEBUG(0,("failed to initialize group mapping\n"));
00595                 return NT_STATUS_ACCESS_DENIED;
00596         }
00597 
00598         if (!get_group_map_from_sid(*alias, &map))
00599                 return NT_STATUS_NO_SUCH_ALIAS;
00600 
00601         if ( (map.sid_name_use != SID_NAME_ALIAS) &&
00602              (map.sid_name_use != SID_NAME_WKN_GRP) )
00603                 return NT_STATUS_NO_SUCH_ALIAS;
00604 
00605         *sids = NULL;
00606         *num = 0;
00607 
00608         closure.alias = alias;
00609         closure.sids = sids;
00610         closure.num = num;
00611 
00612         tdb_traverse(tdb, collect_aliasmem, &closure);
00613         return NT_STATUS_OK;
00614 }


Sambaに対してSat Aug 29 21:23:33 2009に生成されました。  doxygen 1.4.7