ALT Linux Sisyphus - Пакет libnss-fallback

pax_global_header00006660000000000000000000000064121335634260014517gustar00rootroot0000000000000052 comment=8773670f8540b67e65cdd26479c0018ca6fdcb0c
libnss-fallback-0.0.1/000075500000000000000000000000001213356342600145425ustar00rootroot00000000000000libnss-fallback-0.0.1/.gear/000075500000000000000000000000001213356342600155365ustar00rootroot00000000000000libnss-fallback-0.0.1/.gear/rules000064400000000000000000000000071213356342600166100ustar00rootroot00000000000000tar: .
libnss-fallback-0.0.1/CMakeLists.txt000064400000000000000000000003511213356342600173010ustar00rootroot00000000000000cmake_minimum_required(VERSION 2.6)

file(GLOB sources "*.c")
add_library(nss_fallback SHARED ${sources})
set_target_properties(nss_fallback PROPERTIES SOVERSION 2)

install(TARGETS nss_fallback LIBRARY DESTINATION lib${LIB_SUFFIX})
libnss-fallback-0.0.1/libnss-fallback.spec000064400000000000000000000031241213356342600204450ustar00rootroot00000000000000
Name: libnss-fallback
Version: 0.0.1
Release: alt2.qa1

Summary: NSS library module for localhost fallback
License: GPL
Group: System/Libraries

Url: http://www.altlinux.org/Projects/libnss_fallback
Source: %name-%version.tar
Packager: Evgeny Sinelnikov <sin@altlinux.ru>

BuildRequires: gcc-c++ cmake

Requires(pre): chrooted >= 0.3.6-alt1 chrooted-resolv sed
Requires(postun): chrooted >= 0.3.6-alt1 sed

%description
NSS library module for localhost fallback

%prep
%setup %name-%version

%build
mkdir build
cd build
cmake ../ \
        -DCMAKE_INSTALL_PREFIX=/ \
%if %_lib == lib64
        -DLIB_SUFFIX=64 \
%endif
        -DCMAKE_BUILD_TYPE="Release"
#        -DCMAKE_SKIP_RPATH=YES

%make_build VERBOSE=1

%install
cd build
%makeinstall DESTDIR=%buildroot

%post
if [ "$1" = "1" ]; then
    grep -q '^hosts:[[:blank:]]*\(.\+[[:blank:]]\+\)*fallback\($\|[[:blank:]]\)' \
        /etc/nsswitch.conf || \
    sed -i.rpmorig -e 's/^\(hosts:.\+\)$/\1 fallback/g' \
        /etc/nsswitch.conf
fi
update_chrooted all

%postun
if [ "$1" = "0" ]; then
    sed -i -e 's/^hosts:fallback/hosts:/g' \
           -e 's/^\(hosts:\)\(.\+[[:blank:]]*\)*[[:blank:]]\+fallback\($\|[[:blank:]].*\)$/\1\2\3/g' \
        /etc/nsswitch.conf
fi
update_chrooted all

%files
/%_lib/*.so.*

%changelog
* Wed Apr 17 2013 Dmitry V. Levin (QA) <qa_ldv@altlinux.org> 0.0.1-alt2.qa1
- NMU: rebuilt for debuginfo.

* Thu Feb 26 2009 Evgeny Sinelnikov <sin@altlinux.ru> 0.0.1-alt2
- Add automatic module configurtion during installation process

* Sat Nov 22 2008 Evgeny Sinelnikov <sin@altlinux.ru> 0.0.1-alt1
- Initial first release for testing
libnss-fallback-0.0.1/libnss_fallback.c000064400000000000000000000070441213356342600200240ustar00rootroot00000000000000#include <nss.h>
#include <grp.h>

#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <sys/socket.h>
#include <limits.h>

#define NSS_IPV4_ONLY

#ifndef NSS_IPV4_ONLY
#include <arpa/inet.h>
#endif

#include <stdio.h>

typedef struct {
    uint32_t address;
} ipv4_address_t;

typedef struct {
    uint8_t address[16];
} ipv6_address_t;

static void *allocate_mem (char **buf, size_t *buflen, size_t len)
{
	char *next;

	if (!buf || !buflen || (*buflen < len))
		return NULL;

	next = *buf;
	*buf += len;
	*buflen -= len;
	return next;
}

static int hostnamecmp(const char* name, const char* hostname)
{
    const char *ptr;

    if (strcmp(name, hostname) == 0)
        return 0;

    ptr = strchr(hostname, '.');

    if (ptr != NULL && strchr(name, '.') == NULL)
    {
        char buff[HOST_NAME_MAX + 1];

        strncpy(buff, hostname, ptr-hostname);
        buff[ptr-hostname] = 0;

        return strcmp(name, buff);
    }

    return 1;
}

enum nss_status
_nss_fallback_gethostbyname2_r(
    const char *name, int af,
    struct hostent *result,
    char *buffer, size_t buflen,
    int *errnop, int *h_errnop)
{
    enum nss_status status = NSS_STATUS_UNAVAIL;
    size_t address_length;
    char hostname[HOST_NAME_MAX + 1];
    char **addr_list;
    void *addr_ptr;

    if (af == AF_UNSPEC)
        af = AF_INET;

#ifdef NSS_IPV4_ONLY
    if (af != AF_INET)
#elif NSS_IPV6_ONLY
    if (af != AF_INET6)
#else
    if (af != AF_INET && af != AF_INET6)
#endif
    {
        *errnop = EINVAL;
        *h_errnop = NO_RECOVERY;

        goto finish;
    }

    if(gethostname(hostname, HOST_NAME_MAX) != 0)
    {
        *errnop = errno;
        if (errno == EFAULT)
            *errnop = EINVAL;
        *h_errnop = NO_RECOVERY;

        goto finish;
    }

    if (hostnamecmp(name, hostname) != 0)
    {
        status = NSS_STATUS_NOTFOUND;

        goto finish;
    }

    address_length = af == AF_INET ? sizeof(ipv4_address_t) : sizeof(ipv6_address_t);
    addr_ptr = allocate_mem(&buffer, &buflen, address_length);
    addr_list = allocate_mem(&buffer, &buflen, sizeof(char**)*3);
    if (addr_ptr == NULL || addr_list == NULL)
    {
        *errnop = ERANGE;
        *h_errnop = NO_RECOVERY;
        status = NSS_STATUS_TRYAGAIN;

        goto finish;
    }
    addr_list[0] = addr_ptr;
    addr_list[1] = NULL;
    addr_list[2] = NULL;

    result->h_name = allocate_mem(&buffer, &buflen, strlen(hostname)+1);
    if (result == NULL) {
        *errnop = ERANGE;
        *h_errnop = NO_RECOVERY;
        status = NSS_STATUS_TRYAGAIN;

        goto finish;
    }

    strcpy(result->h_name, hostname);

    result->h_addrtype = af;
    result->h_length = address_length;
    result->h_aliases = addr_list+2; /* May be localhost needs? */
    result->h_addr_list = addr_list;

#ifndef NSS_IPV6_ONLY
    if (af == AF_INET)
    {
        ipv4_address_t *ipv4 = addr_ptr;
        ipv4->address = htonl((127 << 24) | 1);
    }
#endif

#ifndef NSS_IPV4_ONLY
    if (af == AF_INET6)
    {
        //ipv6_address_t *ipv6 = addr_ptr;
        //memset(ipv6->address, 0, sizeof(ipv6_address_t));
        //ipv6->address[15] = 1;
        inet_pton(AF_INET6, "::1", addr_ptr);
    }
#endif

    status = NSS_STATUS_SUCCESS;

finish:

    return status;
}

enum nss_status 
_nss_fallback_gethostbyname_r(
    const char *name,
    struct hostent *result,
    char *buffer, size_t buflen,
    int *errnop, int *h_errnop)
{
    return _nss_fallback_gethostbyname2_r(
        name,
        AF_UNSPEC,
        result,
        buffer,
        buflen,
        errnop,
        h_errnop);
}