Changeset 147 for trunk/lib/winsec.c


Ignore:
Timestamp:
02/22/09 14:31:52 (15 years ago)
Author:
tim
Message:

added talloc library

incorporated talloc into winsec and lru_cache modules

introduced talloc into SK caching system

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/lib/winsec.c

    r134 r147  
    2424 */
    2525
    26 #include "../include/winsec.h"
    27 
     26#include "winsec.h"
     27
     28
     29/******************************************************************************
     30 * Non-talloc() interface for parsing a descriptor.
     31 ******************************************************************************/
     32WINSEC_DESC* winsec_parse_descriptor(const uint8_t* buf, uint32_t buf_len)
     33{
     34  return winsec_parse_desc(NULL, buf, buf_len);
     35}
     36
     37
     38/******************************************************************************
     39 * Free a descriptor.  Not needed if using talloc and a parent context is freed.
     40 ******************************************************************************/
     41void winsec_free_descriptor(WINSEC_DESC* desc)
     42{
     43  talloc_free(desc);
     44}
    2845
    2946
    … …  
    3148 * Parses a WINSEC_DESC structure and substructures.
    3249 ******************************************************************************/
    33 WINSEC_DESC* winsec_parse_desc(const uint8_t* buf, uint32_t buf_len)
     50WINSEC_DESC* winsec_parse_desc(void* talloc_ctx,
     51                               const uint8_t* buf, uint32_t buf_len)
    3452{
    3553  WINSEC_DESC* ret_val;
    … …  
    3755  if (buf == NULL || buf_len <  WINSEC_DESC_HEADER_SIZE)
    3856    return NULL;
    39 
     57  /*
    4058  if((ret_val = (WINSEC_DESC*)zalloc(sizeof(WINSEC_DESC))) == NULL)
     59    return NULL;
     60  */
     61  if((ret_val = talloc(talloc_ctx, WINSEC_DESC)) == NULL)
    4162    return NULL;
    4263
    … …  
    6182     || (ret_val->off_dacl >= buf_len))
    6283  {
    63     free(ret_val);
     84    talloc_free(ret_val);
    6485    return NULL;
    6586  }
    … …  
    6788  if(ret_val->off_owner_sid != 0)
    6889  {
    69     ret_val->owner_sid = winsec_parse_dom_sid(buf + ret_val->off_owner_sid,
     90    ret_val->owner_sid = winsec_parse_dom_sid(ret_val,
     91                                              buf + ret_val->off_owner_sid,
    7092                                              buf_len - ret_val->off_owner_sid);
    7193    if(ret_val->owner_sid == NULL)
    7294    {
    73       free(ret_val);
     95      talloc_free(ret_val);
    7496      return NULL;
    7597    }
    … …  
    78100  if (ret_val->off_grp_sid != 0)
    79101  {
    80     ret_val->grp_sid = winsec_parse_dom_sid(buf + ret_val->off_grp_sid,
     102    ret_val->grp_sid = winsec_parse_dom_sid(ret_val, buf + ret_val->off_grp_sid,
    81103                                            buf_len - ret_val->off_grp_sid);
    82104    if(ret_val->grp_sid == NULL)
    83105    {
    84       if(ret_val->owner_sid != NULL)
    85         free(ret_val->owner_sid);
    86       free(ret_val);
     106      talloc_free(ret_val);
    87107      return NULL;
    88108    }
    … …  
    91111  if ((ret_val->control & WINSEC_DESC_SACL_PRESENT) && ret_val->off_sacl)
    92112  {
    93     ret_val->sacl = winsec_parse_acl(buf + ret_val->off_sacl,
     113    ret_val->sacl = winsec_parse_acl(ret_val, buf + ret_val->off_sacl,
    94114                                     buf_len - ret_val->off_sacl);
    95115    if(ret_val->sacl == NULL)
    96116    {
    97       if(ret_val->owner_sid != NULL)
    98         free(ret_val->owner_sid);
    99       if(ret_val->grp_sid != NULL)
    100         free(ret_val->grp_sid);
    101       free(ret_val);
     117      talloc_free(ret_val);
    102118      return NULL;
    103119    }
    … …  
    106122  if ((ret_val->control & WINSEC_DESC_DACL_PRESENT) && ret_val->off_dacl != 0)
    107123  {
    108     ret_val->dacl = winsec_parse_acl(buf + ret_val->off_dacl,
     124    ret_val->dacl = winsec_parse_acl(ret_val, buf + ret_val->off_dacl,
    109125                                     buf_len - ret_val->off_dacl);
    110126    if(ret_val->dacl == NULL)
    111127    {
    112       if(ret_val->owner_sid != NULL)
    113         free(ret_val->owner_sid);
    114       if(ret_val->grp_sid != NULL)
    115         free(ret_val->grp_sid);
    116       if(ret_val->sacl != NULL)
    117         free(ret_val->sacl);
    118       free(ret_val);
     128      talloc_free(ret_val);
    119129      return NULL;
    120130    }
    … …  
    128138 * Parses a WINSEC_ACL structure and all substructures.
    129139 ******************************************************************************/
    130 WINSEC_ACL* winsec_parse_acl(const uint8_t* buf, uint32_t buf_len)
     140WINSEC_ACL* winsec_parse_acl(void* talloc_ctx,
     141                             const uint8_t* buf, uint32_t buf_len)
    131142{
    132143  uint32_t i, offset;
    … …  
    139150  if (buf == NULL || buf_len < 8)
    140151    return NULL;
    141 
     152  /*
    142153  if((ret_val = (WINSEC_ACL*)zalloc(sizeof(WINSEC_ACL))) == NULL)
     154    return NULL;
     155  */
     156  if((ret_val = talloc(talloc_ctx, WINSEC_ACL)) == NULL)
    143157    return NULL;
    144158 
    … …  
    153167  if((ret_val->size > buf_len) || (ret_val->num_aces > 4095))
    154168  {
    155     free(ret_val);
     169    talloc_free(ret_val);
    156170    return NULL;
    157171  }
    … …  
    161175   * (allow no access).
    162176   */
    163   if((ret_val->aces = (WINSEC_ACE**)zcalloc(sizeof(WINSEC_ACE*),
     177  /*  if((ret_val->aces = (WINSEC_ACE**)zcalloc(sizeof(WINSEC_ACE*),
    164178                                           ret_val->num_aces+1)) == NULL)
    165   {
    166     free(ret_val);
     179  */
     180  if((ret_val->aces = talloc_array(ret_val, WINSEC_ACE*,
     181                                   ret_val->num_aces+1)) == NULL)
     182  {
     183    talloc_free(ret_val);
    167184    return NULL;
    168185  }
    … …  
    171188  for(i=0; i < ret_val->num_aces; i++)
    172189  {
    173     ret_val->aces[i] = winsec_parse_ace(buf+offset, buf_len-offset);
     190    ret_val->aces[i] = winsec_parse_ace(ret_val->aces,
     191                                        buf+offset, buf_len-offset);
    174192    if(ret_val->aces[i] == NULL)
    175193    {
    176       free(ret_val->aces);
    177       free(ret_val);
     194      talloc_free(ret_val);
    178195      return NULL;
    179196    }
    … …  
    182199    if(offset > buf_len)
    183200    {
    184       free(ret_val->aces);
    185       free(ret_val);
     201      talloc_free(ret_val);
    186202      return NULL;
    187203    }
    … …  
    195211 * Parses a WINSEC_ACE structure and all substructures.
    196212 ******************************************************************************/
    197 WINSEC_ACE* winsec_parse_ace(const uint8_t* buf, uint32_t buf_len)
     213WINSEC_ACE* winsec_parse_ace(void* talloc_ctx,
     214                             const uint8_t* buf, uint32_t buf_len)
    198215{
    199216  uint32_t offset;
    … …  
    203220    return NULL;
    204221
    205   if((ret_val = (WINSEC_ACE*)zalloc(sizeof(WINSEC_ACE))) == NULL)
     222  /*  if((ret_val = (WINSEC_ACE*)zalloc(sizeof(WINSEC_ACE))) == NULL)*/
     223
     224  if((ret_val = talloc(talloc_ctx, WINSEC_ACE)) == NULL)
    206225    return NULL;
    207226
    … …  
    221240    if(ret_val->obj_flags & WINSEC_ACE_OBJECT_PRESENT)
    222241    {
    223       ret_val->obj_guid = winsec_parse_uuid(buf+offset, buf_len-offset);
     242      ret_val->obj_guid = winsec_parse_uuid(ret_val,
     243                                            buf+offset, buf_len-offset);
    224244      if(ret_val->obj_guid == NULL)
    225245      {
    226         free(ret_val);
     246        talloc_free(ret_val);
    227247        return NULL;
    228248      }
    … …  
    232252    if(ret_val->obj_flags & WINSEC_ACE_OBJECT_INHERITED_PRESENT)
    233253    {
    234       ret_val->inh_guid = winsec_parse_uuid(buf+offset, buf_len-offset);
     254      ret_val->inh_guid = winsec_parse_uuid(ret_val,
     255                                            buf+offset, buf_len-offset);
    235256      if(ret_val->inh_guid == NULL)
    236257      {
    237         if(ret_val->obj_guid != NULL)
    238           free(ret_val->obj_guid);
    239         free(ret_val);
     258        talloc_free(ret_val);
    240259        return NULL;
    241260      }
    … …  
    244263  }
    245264
    246   ret_val->trustee = winsec_parse_dom_sid(buf+offset, buf_len-offset);
     265  ret_val->trustee = winsec_parse_dom_sid(ret_val, buf+offset, buf_len-offset);
    247266  if(ret_val->trustee == NULL)
    248267  {
    249     if(ret_val->obj_guid != NULL)
    250       free(ret_val->obj_guid);
    251     if(ret_val->inh_guid != NULL)
    252       free(ret_val->inh_guid);
    253     free(ret_val);
    254         return NULL;
     268    talloc_free(ret_val);
     269    return NULL;
    255270  }
    256271 
    … …  
    262277 * Parses a WINSEC_DOM_SID structure.
    263278 ******************************************************************************/
    264 WINSEC_DOM_SID* winsec_parse_dom_sid(const uint8_t* buf, uint32_t buf_len)
     279WINSEC_DOM_SID* winsec_parse_dom_sid(void* talloc_ctx,
     280                                     const uint8_t* buf, uint32_t buf_len)
    265281{
    266282  uint32_t i;
    … …  
    270286    return NULL;
    271287
    272   if((ret_val = (WINSEC_DOM_SID*)zalloc(sizeof(WINSEC_DOM_SID))) == NULL)
     288  /*  if((ret_val = (WINSEC_DOM_SID*)zalloc(sizeof(WINSEC_DOM_SID))) == NULL)*/
     289  if((ret_val = talloc(talloc_ctx, WINSEC_DOM_SID)) == NULL)
    273290    return NULL;
    274291
    … …  
    283300  if(buf_len < ret_val->num_auths*sizeof(uint32_t)+8)
    284301  {
    285     free(ret_val);
     302    talloc_free(ret_val);
    286303    return NULL;
    287304  }
    … …  
    297314 * Parses a WINSEC_UUID struct.
    298315 ******************************************************************************/
    299 WINSEC_UUID* winsec_parse_uuid(const uint8_t* buf, uint32_t buf_len)
     316WINSEC_UUID* winsec_parse_uuid(void* talloc_ctx,
     317                               const uint8_t* buf, uint32_t buf_len)
    300318{
    301319  WINSEC_UUID* ret_val;
    … …  
    304322    return false;
    305323
    306   if((ret_val = (WINSEC_UUID*)zalloc(sizeof(WINSEC_UUID))) == NULL)
     324  /* if((ret_val = (WINSEC_UUID*)zalloc(sizeof(WINSEC_UUID))) == NULL)*/
     325  if((ret_val = talloc(talloc_ctx, WINSEC_UUID)) == NULL)
    307326    return NULL;
    308327 
    … …  
    321340 * Calculates the size of a SID.
    322341 ******************************************************************************/
    323 /*size_t sid_size(const WINSEC_DOM_SID *sid)*/
    324342size_t winsec_sid_size(const WINSEC_DOM_SID* sid)
    325343{
    … …  
    334352 * Compare the auth portion of two SIDs.
    335353 ******************************************************************************/
    336 /*int sid_compare_auth(const WINSEC_DOM_SID *sid1, const WINSEC_DOM_SID *sid2)*/
    337354int winsec_sid_compare_auth(const WINSEC_DOM_SID* sid1, const WINSEC_DOM_SID* sid2)
    338355{
    … …  
    360377 * Compare two SIDs.
    361378 ******************************************************************************/
    362 /*int sid_compare(const WINSEC_DOM_SID *sid1, const WINSEC_DOM_SID *sid2)*/
    363379int winsec_sid_compare(const WINSEC_DOM_SID* sid1, const WINSEC_DOM_SID* sid2)
    364380{
Note: See TracChangeset for help on using the changeset viewer.