Ignore:
Timestamp:
May 26, 2009, 9:44:50 AM (16 years ago)
Author:
Herwig Bauernfeind
Message:

Update 3.2 branch to 3.2.6

Location:
branches/samba-3.2.x/source/lib
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • branches/samba-3.2.x/source/lib/charcnv.c

    r149 r228  
    11841184        *ppdest = NULL;
    11851185
     1186        if (!src_len) {
     1187                return 0;
     1188        }
     1189
    11861190        if (flags & STR_TERMINATE) {
    11871191                if (src_len == (size_t)-1) {
    … …  
    12011205                        smb_panic(msg);
    12021206                }
    1203         }
     1207        } else {
     1208                /* Can't have an unlimited length
     1209                 * non STR_TERMINATE'd.
     1210                 */
     1211                if (src_len == (size_t)-1) {
     1212                        errno = EINVAL;
     1213                        return 0;
     1214                }
     1215        }
     1216
     1217        /* src_len != -1 here. */
    12041218
    12051219        if (!convert_string_allocate(ctx, CH_DOS, CH_UNIX, src, src_len, &dest,
    1206                 &dest_len, True))
     1220                &dest_len, True)) {
    12071221                dest_len = 0;
     1222        }
    12081223
    12091224        if (dest_len && dest) {
    12101225                /* Did we already process the terminating zero ? */
    12111226                if (dest[dest_len-1] != 0) {
    1212                         dest[dest_len-1] = 0;
     1227                        size_t size = talloc_get_size(dest);
     1228                        /* Have we got space to append the '\0' ? */
     1229                        if (size <= dest_len) {
     1230                                /* No, realloc. */
     1231                                dest = TALLOC_REALLOC_ARRAY(ctx, dest, char,
     1232                                                dest_len+1);
     1233                                if (!dest) {
     1234                                        /* talloc fail. */
     1235                                        dest_len = (size_t)-1;
     1236                                        return 0;
     1237                                }
     1238                        }
     1239                        /* Yay - space ! */
     1240                        dest[dest_len] = '\0';
     1241                        dest_len++;
    12131242                }
    12141243        } else if (dest) {
    … …  
    15581587                        smb_panic("Bad src length in pull_ucs2_base_talloc\n");
    15591588                }
    1560         }
     1589        } else {
     1590                /* Can't have an unlimited length
     1591                 * non STR_TERMINATE'd.
     1592                 */
     1593                if (src_len == (size_t)-1) {
     1594                        errno = EINVAL;
     1595                        return 0;
     1596                }
     1597        }
     1598
     1599        /* src_len != -1 here. */
    15611600
    15621601        /* ucs2 is always a multiple of 2 bytes */
    1563         if (src_len != (size_t)-1) {
    1564                 src_len &= ~1;
    1565         }
     1602        src_len &= ~1;
    15661603
    15671604        dest_len = convert_string_talloc(ctx,
    … …  
    15751612                dest_len = 0;
    15761613        }
    1577 
    1578         if (src_len == (size_t)-1)
    1579                 src_len = dest_len*2;
    15801614
    15811615        if (dest_len) {

  • branches/samba-3.2.x/source/lib/debug.c

    r149 r228  
    579579        if (dbf) {
    580580                x_fflush(dbf);
    581                 (void) x_fclose(dbf);
     581                if (dbf != x_stdout) {
     582                        (void) x_fclose(dbf);
     583                }
    582584        }
    583585
    … …  
    850852                va_end(ap);
    851853
    852                 if (ret == -1) {
     854                if (ret != -1) {
    853855                        syslog(priority, "%s", msgbuf);
    854856                }

  • branches/samba-3.2.x/source/lib/dummysmbd.c

    r133 r228  
    5252        return NT_STATUS_OK;
    5353}
     54
     55struct event_context *smbd_event_context(void)
     56{
     57        return NULL;
     58}
     59
     60struct messaging_context *smbd_messaging_context(void)
     61{
     62        return NULL;
     63}

  • branches/samba-3.2.x/source/lib/interface.c

    r204 r228  
    3434        struct interface *i;
    3535        for (i=local_interfaces;i;i=i->next) {
    36                 if (addr_equal(&i->ip,ip)) {
     36                if (sockaddr_equal(&i->ip,ip)) {
    3737                        return true;
    3838                }
    … …  
    6666                                return i;
    6767                        }
    68                 } else if (addr_equal(&i->ip, ip)) {
     68                } else if (sockaddr_equal(&i->ip, ip)) {
    6969                        return i;
    7070                }
    … …  
    9494        struct interface *i;
    9595        for (i=local_interfaces;i;i=i->next) {
    96                 if (addr_equal(&i->ip,pss)) {
     96                if (sockaddr_equal(&i->ip,pss)) {
    9797                        struct sockaddr_in6 *psa6 =
    9898                                (struct sockaddr_in6 *)pss;
    … …  
    389389
    390390                for (i=0;i<total_probed;i++) {
    391                         if (addr_equal(&ss, &probed_ifaces[i].ip)) {
     391                        if (sockaddr_equal(&ss, &probed_ifaces[i].ip)) {
    392392                                add_interface(&probed_ifaces[i]);
    393393                                return;
    … …  
    442442
    443443        /* Maybe the first component was a broadcast address. */
    444         if (addr_equal(&ss_bcast, &ss) || addr_equal(&ss_net, &ss)) {
     444        if (sockaddr_equal(&ss_bcast, &ss) || sockaddr_equal(&ss_net, &ss)) {
    445445                for (i=0;i<total_probed;i++) {
    446446                        if (same_net(&ss, &probed_ifaces[i].ip, &ss_mask)) {

  • branches/samba-3.2.x/source/lib/memcache.c

    r136 r228  
    215215        DLIST_REMOVE(cache->mru, e);
    216216
     217        if (memcache_is_talloc(e->n)) {
     218                DATA_BLOB cache_key, cache_value;
     219                void *ptr;
     220
     221                memcache_element_parse(e, &cache_key, &cache_value);
     222                SMB_ASSERT(cache_value.length == sizeof(ptr));
     223                memcpy(&ptr, cache_value.data, sizeof(ptr));
     224                TALLOC_FREE(ptr);
     225        }
     226
    217227        cache->size -= memcache_element_size(e->keylength, e->valuelength);
    218228
    … …  
    277287
    278288                if (value.length <= cache_value.length) {
     289                        if (memcache_is_talloc(e->n)) {
     290                                void *ptr;
     291                                SMB_ASSERT(cache_value.length == sizeof(ptr));
     292                                memcpy(&ptr, cache_value.data, sizeof(ptr));
     293                                TALLOC_FREE(ptr);
     294                        }
    279295                        /*
    280296                         * We can reuse the existing record
    … …  
    333349
    334350void memcache_add_talloc(struct memcache *cache, enum memcache_number n,
    335                          DATA_BLOB key, void *ptr)
    336 {
    337         memcache_add(cache, n, key, data_blob_const(&ptr, sizeof(ptr)));
     351                         DATA_BLOB key, void *pptr)
     352{
     353        void **ptr = (void **)pptr;
     354        void *p;
     355
     356        if (cache == NULL) {
     357                cache = global_cache;
     358        }
     359        if (cache == NULL) {
     360                return;
     361        }
     362
     363        p = talloc_move(cache, ptr);
     364        memcache_add(cache, n, key, data_blob_const(&p, sizeof(p)));
    338365}
    339366

  • branches/samba-3.2.x/source/lib/netapi/getdc.c

    r136 r228  
    6161                                       (const char **)r->out.buffer,
    6262                                       &werr);
     63
     64        if (!NT_STATUS_IS_OK(status)) {
     65                werr = ntstatus_to_werror(status);
     66        }
     67
    6368 done:
    6469

  • branches/samba-3.2.x/source/lib/popt_common.c

    r136 r228  
    167167
    168168struct poptOption popt_common_version[] = {
    169         { NULL, 0, POPT_ARG_CALLBACK, (void *)popt_common_callback },
     169        { NULL, 0, POPT_ARG_CALLBACK|POPT_CBFLAG_POST, (void *)popt_common_callback },
    170170        { "version", 'V', POPT_ARG_NONE, NULL, 'V', "Print version" },
    171171        POPT_TABLEEND

  • branches/samba-3.2.x/source/lib/readline.c

    r133 r228  
    4646#endif /* HAVE_NEW_LIBREADLINE */
    4747
     48static bool smb_rl_done;
     49
     50#if HAVE_LIBREADLINE
     51/*
     52 *  * MacOS/X does not have rl_done in readline.h, but
     53 *   * readline.so has it
     54 *    */
     55extern int rl_done;
     56#endif
     57
     58void smb_readline_done(void)
     59{
     60        smb_rl_done = true;
     61#if HAVE_LIBREADLINE
     62        rl_done = 1;
     63#endif
     64}
     65
    4866/****************************************************************************
    4967 Display the prompt and wait for input. Call callback() regularly
    … …  
    7088        }
    7189
    72         while (1) {
     90        while (!smb_rl_done) {
    7391                timeout.tv_sec = 5;
    7492                timeout.tv_usec = 0;
    … …  
    88106                }
    89107        }
     108        SAFE_FREE(line);
     109        return NULL;
    90110}
    91111

  • branches/samba-3.2.x/source/lib/replace/autoconf-2.60.m4

    r133 r228  
    180180# Enable extensions on systems that normally disable them,
    181181# typically due to standards-conformance issues.
     182m4_ifndef([AC_USE_SYSTEM_EXTENSIONS],[
    182183AC_DEFUN([AC_USE_SYSTEM_EXTENSIONS],
    183184[
    … …  
    209210  AC_DEFINE([_POSIX_PTHREAD_SEMANTICS])
    210211])
     212])

  • branches/samba-3.2.x/source/lib/smbldap.c

    r141 r228  
    10241024        bool reopen = False;
    10251025        SMB_ASSERT(ldap_state);
    1026                
    1027 #ifndef NO_LDAP_SECURITY
    1028         if (geteuid() != 0) {
    1029                 DEBUG(0, ("smbldap_open: cannot access LDAP when not root\n"));
    1030                 return  LDAP_INSUFFICIENT_ACCESS;
    1031         }
    1032 #endif
    10331026
    10341027        if ((ldap_state->ldap_struct != NULL) && ((ldap_state->last_ping + SMBLDAP_DONT_PING_TIME) < time(NULL))) {

  • branches/samba-3.2.x/source/lib/socket_wrapper/socket_wrapper.c

    r133 r228  
    626626                                              const unsigned char *payload,
    627627                                              size_t payload_len,
    628                                               unsigned long tcp_seq,
     628                                              unsigned long tcp_seqno,
    629629                                              unsigned long tcp_ack,
    630630                                              unsigned char tcp_ctl,
    … …  
    725725                packet->ip.p.tcp.source_port    = src_port;
    726726                packet->ip.p.tcp.dest_port      = dest_port;
    727                 packet->ip.p.tcp.seq_num        = htonl(tcp_seq);
     727                packet->ip.p.tcp.seq_num        = htonl(tcp_seqno);
    728728                packet->ip.p.tcp.ack_num        = htonl(tcp_ack);
    729729                packet->ip.p.tcp.hdr_length     = 0x50; /* 5 * 32 bit words */
    … …  
    788788        const struct sockaddr_in *dest_addr;
    789789        const char *file_name;
    790         unsigned long tcp_seq = 0;
     790        unsigned long tcp_seqno = 0;
    791791        unsigned long tcp_ack = 0;
    792792        unsigned char tcp_ctl = 0;
    … …  
    813813                dest_addr = (const struct sockaddr_in *)addr;
    814814
    815                 tcp_seq = si->io.pck_snd;
     815                tcp_seqno = si->io.pck_snd;
    816816                tcp_ack = si->io.pck_rcv;
    817817                tcp_ctl = 0x02; /* SYN */
    … …  
    827827                src_addr = (const struct sockaddr_in *)addr;
    828828
    829                 tcp_seq = si->io.pck_rcv;
     829                tcp_seqno = si->io.pck_rcv;
    830830                tcp_ack = si->io.pck_snd;
    831831                tcp_ctl = 0x12; /** SYN,ACK */
    … …  
    842842
    843843                /* Unreachable: resend the data of SWRAP_CONNECT_SEND */
    844                 tcp_seq = si->io.pck_snd - 1;
     844                tcp_seqno = si->io.pck_snd - 1;
    845845                tcp_ack = si->io.pck_rcv;
    846846                tcp_ctl = 0x02; /* SYN */
    … …  
    855855                dest_addr = (const struct sockaddr_in *)addr;
    856856
    857                 tcp_seq = si->io.pck_snd;
     857                tcp_seqno = si->io.pck_snd;
    858858                tcp_ack = si->io.pck_rcv;
    859859                tcp_ctl = 0x10; /* ACK */
    … …  
    867867                src_addr = (const struct sockaddr_in *)addr;
    868868
    869                 tcp_seq = si->io.pck_rcv;
     869                tcp_seqno = si->io.pck_rcv;
    870870                tcp_ack = si->io.pck_snd;
    871871                tcp_ctl = 0x02; /* SYN */
    … …  
    881881                dest_addr = (const struct sockaddr_in *)addr;
    882882
    883                 tcp_seq = si->io.pck_snd;
     883                tcp_seqno = si->io.pck_snd;
    884884                tcp_ack = si->io.pck_rcv;
    885885                tcp_ctl = 0x12; /* SYN,ACK */
    … …  
    895895                src_addr = (const struct sockaddr_in *)addr;
    896896
    897                 tcp_seq = si->io.pck_rcv;
     897                tcp_seqno = si->io.pck_rcv;
    898898                tcp_ack = si->io.pck_snd;
    899899                tcp_ctl = 0x10; /* ACK */
    … …  
    905905                dest_addr = (const struct sockaddr_in *)si->peername;
    906906
    907                 tcp_seq = si->io.pck_snd;
     907                tcp_seqno = si->io.pck_snd;
    908908                tcp_ack = si->io.pck_rcv;
    909909                tcp_ctl = 0x18; /* PSH,ACK */
    … …  
    924924                }
    925925
    926                 tcp_seq = si->io.pck_rcv;
     926                tcp_seqno = si->io.pck_rcv;
    927927                tcp_ack = si->io.pck_snd;
    928928                tcp_ctl = 0x14; /** RST,ACK */
    … …  
    938938                }
    939939
    940                 tcp_seq = si->io.pck_rcv;
     940                tcp_seqno = si->io.pck_rcv;
    941941                tcp_ack = si->io.pck_snd;
    942942                tcp_ctl = 0x14; /* RST,ACK */
    … …  
    948948                src_addr = (const struct sockaddr_in *)si->peername;
    949949
    950                 tcp_seq = si->io.pck_rcv;
     950                tcp_seqno = si->io.pck_rcv;
    951951                tcp_ack = si->io.pck_snd;
    952952                tcp_ctl = 0x18; /* PSH,ACK */
    … …  
    964964                }
    965965
    966                 tcp_seq = si->io.pck_rcv;
     966                tcp_seqno = si->io.pck_rcv;
    967967                tcp_ack = si->io.pck_snd;
    968968                tcp_ctl = 0x14; /* RST,ACK */
    … …  
    10001000                dest_addr = (const struct sockaddr_in *)si->peername;
    10011001
    1002                 tcp_seq = si->io.pck_snd;
     1002                tcp_seqno = si->io.pck_snd;
    10031003                tcp_ack = si->io.pck_rcv;
    10041004                tcp_ctl = 0x11; /* FIN, ACK */
    … …  
    10141014                src_addr = (const struct sockaddr_in *)si->peername;
    10151015
    1016                 tcp_seq = si->io.pck_rcv;
     1016                tcp_seqno = si->io.pck_rcv;
    10171017                tcp_ack = si->io.pck_snd;
    10181018                tcp_ctl = 0x11; /* FIN,ACK */
    … …  
    10281028                dest_addr = (const struct sockaddr_in *)si->peername;
    10291029
    1030                 tcp_seq = si->io.pck_snd;
     1030                tcp_seqno = si->io.pck_snd;
    10311031                tcp_ack = si->io.pck_rcv;
    10321032                tcp_ctl = 0x10; /* ACK */
    … …  
    10411041        packet = swrap_packet_init(&tv, src_addr, dest_addr, si->type,
    10421042                                   (const unsigned char *)buf, len,
    1043                                    tcp_seq, tcp_ack, tcp_ctl, unreachable,
     1043                                   tcp_seqno, tcp_ack, tcp_ctl, unreachable,
    10441044                                   &packet_len);
    10451045        if (!packet) {

  • branches/samba-3.2.x/source/lib/util_pw.c

    r133 r228  
    4545struct passwd *getpwnam_alloc(TALLOC_CTX *mem_ctx, const char *name)
    4646{
    47         struct passwd *temp, *cached;
     47        struct passwd *pw, *for_cache;
    4848
    49         temp = (struct passwd *)memcache_lookup_talloc(
     49        pw = (struct passwd *)memcache_lookup_talloc(
    5050                NULL, GETPWNAM_CACHE, data_blob_string_const(name));
    51         if (temp != NULL) {
    52                 return tcopy_passwd(mem_ctx, temp);
     51        if (pw != NULL) {
     52                return tcopy_passwd(mem_ctx, pw);
    5353        }
    5454
    55         temp = sys_getpwnam(name);
    56         if (temp == NULL) {
     55        pw = sys_getpwnam(name);
     56        if (pw == NULL) {
    5757                return NULL;
    5858        }
    5959
    60         cached = tcopy_passwd(NULL, temp);
    61         if (cached == NULL) {
    62                 /*
    63                  * Just don't add this into the cache, ignore the failure
    64                  */
    65                 return temp;
     60        for_cache = tcopy_passwd(NULL, pw);
     61        if (for_cache == NULL) {
     62                return NULL;
    6663        }
    6764
    6865        memcache_add_talloc(NULL, GETPWNAM_CACHE, data_blob_string_const(name),
    69                             cached);
    70         return tcopy_passwd(mem_ctx, temp);
     66                            &for_cache);
     67
     68        return tcopy_passwd(mem_ctx, pw);
    7169}
    7270

  • branches/samba-3.2.x/source/lib/util_sid.c

    r149 r228  
    665665}
    666666
     667bool is_sid_in_token(const NT_USER_TOKEN *token, const DOM_SID *sid)
     668{
     669        int i;
     670
     671        for (i=0; i<token->num_sids; i++) {
     672                if (sid_compare(sid, &token->user_sids[i]) == 0)
     673                        return true;
     674        }
     675        return false;
     676}
     677
    667678NTSTATUS sid_array_from_info3(TALLOC_CTX *mem_ctx,
    668679                              const struct netr_SamInfo3 *info3,

  • branches/samba-3.2.x/source/lib/util_sock.c

    r204 r228  
    235235#endif
    236236
    237         zero_addr(pss);
     237        zero_sockaddr(pss);
    238238
    239239        if (!interpret_string_addr_internal(&res, str, flags|AI_ADDRCONFIG)) {
    … …  
    335335******************************************************************/
    336336
    337 void zero_addr(struct sockaddr_storage *pss)
     337void zero_sockaddr(struct sockaddr_storage *pss)
    338338{
    339339        memset(pss, '\0', sizeof(*pss));
    … …  
    430430********************************************************************/
    431431
    432 bool addr_equal(const struct sockaddr_storage *ip1,
    433                 const struct sockaddr_storage *ip2)
     432bool sockaddr_equal(const struct sockaddr_storage *ip1,
     433                    const struct sockaddr_storage *ip2)
    434434{
    435435        if (ip1->ss_family != ip2->ss_family) {
    … …  
    16601660                        continue;
    16611661                }
    1662                 if (addr_equal((const struct sockaddr_storage *)res->ai_addr,
     1662                if (sockaddr_equal((const struct sockaddr_storage *)res->ai_addr,
    16631663                                        pss)) {
    16641664                        freeaddrinfo(ailist);
    … …  
    17731773
    17741774        /* it might be the same as the last one - save some DNS work */
    1775         if (addr_equal(&ss, &nc.ss)) {
     1775        if (sockaddr_equal(&ss, &nc.ss)) {
    17761776                return nc.name ? nc.name : "UNKNOWN";
    17771777        }
    … …  
    20972097                n = get_interfaces(nics, MAX_INTERFACES);
    20982098                for (i=0; i<n; i++) {
    2099                         if (addr_equal(&nics[i].ip, &ss)) {
     2099                        if (sockaddr_equal(&nics[i].ip, &ss)) {
    21002100                                TALLOC_FREE(nics);
    21012101                                return true;
Note: See TracChangeset for help on using the changeset viewer.