android_development/ndk/sources/android/libportable/arch-mips/socket.c

/*
 * Copyright 2012, The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <unistd.h>
#include <sys/socket.h>
#include <fcntl.h>

#include <socket_portable.h>
#include <fcntl_portable.h>
#include <portability.h>

#define PORTABLE_TAG "socket_portable"
#include <log_portable.h>


#if SOCK_STREAM==SOCK_STREAM_PORTABLE
#error Bad build environment
#endif

/* LTP defaults to using O_NONBLOCK if SOCK_NONBLOCK is not defined. */
#ifndef SOCK_NONBLOCK_PORTABLE
# define SOCK_NONBLOCK_PORTABLE O_NONBLOCK_PORTABLE
#endif
#ifndef SOCK_NONBLOCK
# define SOCK_NONBLOCK O_NONBLOCK
#endif

/* Current NDK headers do not define SOCK_CLOEXEC or O_CLOEXEC */
#if !defined(SOCK_CLOEXEC_PORTABLE) && defined(O_CLOEXEC_PORTABLE)
# define SOCK_CLOEXEC_PORTABLE O_CLOEXEC_PORTABLE
#endif
#if !defined(SOCK_CLOEXEC) && defined(O_CLOEXEC)
# define SOCK_CLOEXEC O_CLOEXEC
#endif


/*
 * Portable to Native socktype mapper.
 */
static inline int socktype_pton(int portable_type)
{
    int native_type = 0;

    ALOGV("%s(portable_type:0x%x) {", __func__, portable_type);

    if (portable_type & SOCK_NONBLOCK_PORTABLE) {
        native_type |= SOCK_NONBLOCK;
        portable_type &= ~SOCK_NONBLOCK_PORTABLE;
    }

#if defined(SOCK_CLOEXEC_PORTABLE) && defined(SOCK_CLOEXEC)
    if (portable_type & SOCK_CLOEXEC_PORTABLE) {
        native_type |= SOCK_CLOEXEC;
        portable_type &= ~SOCK_CLOEXEC_PORTABLE;
    }
#endif

    switch (portable_type) {
    case SOCK_STREAM_PORTABLE: native_type |= SOCK_STREAM; break;
    case SOCK_DGRAM_PORTABLE: native_type |= SOCK_DGRAM; break;
    case SOCK_RAW_PORTABLE: native_type |= SOCK_RAW; break;
    case SOCK_RDM_PORTABLE: native_type |= SOCK_RDM; break;
    case SOCK_SEQPACKET_PORTABLE: native_type |= SOCK_SEQPACKET; break;
    case SOCK_PACKET_PORTABLE: native_type |= SOCK_PACKET; break;
    default:
        ALOGE("%s: case default: native_type:0x%x |= portable_type:0x%x:[UNKNOWN!];", __func__,
                                 native_type,        portable_type);

        native_type |= portable_type;
        break;
    }
    ALOGV("%s: return(native_type:%d); }", __func__, native_type);
    return native_type;
}


/*
 * Native to Portable socktype mapper.
 */
static inline int socktype_ntop(int native_type)
{
    int portable_type = 0;

    ALOGV("%s(native_type:0x%x) {", __func__, native_type);

    if (native_type & SOCK_NONBLOCK) {
        portable_type |= SOCK_NONBLOCK_PORTABLE;
        native_type &= ~SOCK_NONBLOCK;
    }

#if defined(SOCK_CLOEXEC_PORTABLE) && defined(SOCK_CLOEXEC)
    if (native_type & SOCK_CLOEXEC) {
        portable_type |= SOCK_CLOEXEC_PORTABLE;
        native_type &= ~SOCK_CLOEXEC;
    }
#endif

    switch (native_type) {
    case SOCK_STREAM: portable_type |= SOCK_STREAM_PORTABLE; break;
    case SOCK_DGRAM: portable_type |= SOCK_DGRAM_PORTABLE; break;
    case SOCK_RAW: portable_type |= SOCK_RAW_PORTABLE; break;
    case SOCK_RDM: portable_type |= SOCK_RDM_PORTABLE; break;
    case SOCK_SEQPACKET: portable_type |= SOCK_SEQPACKET_PORTABLE; break;
    case SOCK_PACKET: portable_type |= SOCK_PACKET_PORTABLE; break;
    default:
        portable_type |= native_type;
        ALOGE("%s: case default: portable_type:0x%x |= native_type:0x%x:[UNKNOWN!];", __func__,
                                 portable_type,        native_type);
    }
    ALOGV("%s: return(portable_type:%d); }", __func__, portable_type);
    return portable_type;
}


extern int socket(int, int, int);

int socket_portable(int domain, int type, int protocol) {
    int rv;

    ALOGV(" ");
    ALOGV("%s(domain:%d, type:%d, protocol:%d) {", __func__,
              domain,    type,    protocol);

    rv = socket(domain, socktype_pton(type), protocol);

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int socketpair_portable(int domain, int type, int protocol, int sv[2]) {
    int rv;

    ALOGV(" ");
    ALOGV("%s(domain:%d, type:%d, protocol:%d, sv[2]:%p) {", __func__,
              domain,    type,    protocol,    sv);

    rv = socketpair(domain, socktype_pton(type), protocol, sv);

    if ((rv != 0) || invalid_pointer(sv)) {
        ALOGV("%s: return(rv:%d); }", __func__,
                          rv);
    } else {
        ALOGV("%s: return(rv:%d); sv[0]:%d; sv[1]:%d;}", __func__,
                          rv,     sv[0],    sv[1]);
    }
    return rv;
}