static TACommandVerdict getpriority_cmd(TAThread thread,TAInputStream stream)
{
   int which;
   int who  ;
   int res  ;

   // Prepare
   which = readInt( & stream );
   who   = readInt( & stream );
   errno = 0;

   // Execute
   START_TARGET_OPERATION(thread);
   res = getpriority( which, who );
   END_TARGET_OPERATION(thread);

   // Response
   writeInt( thread, res   );
   writeInt( thread, errno );
   sendResponse( thread );

   return taDefaultVerdict;
}

static TACommandVerdict gzdopen_cmd(TAThread thread,TAInputStream stream)
{
    char *mode;
    void* res;
    int fd;

    fd = readInt(&stream);
    mode = readString(&stream);

    START_TARGET_OPERATION(thread);

    errno=0;
    res = gzdopen(fd, mode);

    END_TARGET_OPERATION(thread);

    writeInt(thread, errno);
    writePointer(thread, res);

    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict gzprintf_cmd(TAThread thread,TAInputStream stream)
{
    void* file;
    char* s;
    int res, errnum;

    file = readPointer(&stream);
    s = readString(&stream);

    START_TARGET_OPERATION(thread);

    res = gzprintf(file, s);

    END_TARGET_OPERATION(thread);

    writeInt(thread, errnum);
    writeInt(thread, errno);
    writeInt(thread, res);

    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict wcscat_cmd(TAThread thread,TAInputStream stream)
{
    wchar_t* ws1;
    wchar_t* ws2;
    wchar_t* res;

    // Prepare
    ws1 = (wchar_t*)readPointer(&stream);
    ws2 = (wchar_t*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = wcscat(ws1, ws2);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict gztell_cmd(TAThread thread,TAInputStream stream)
{
    void* file;
    z_off_t res;
    int errnum;

    file = readPointer(&stream);

    START_TARGET_OPERATION(thread);

    res = gztell(file);

    END_TARGET_OPERATION(thread);

    gzerror(file, &errnum);

    writeInt(thread, errnum);
    writeLLong(thread, (long long)res);

    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict wcpcpy_cmd(TAThread thread,TAInputStream stream)
{
    wchar_t* dest;
    wchar_t* src;
    wchar_t* res;

    // Prepare
    dest = (wchar_t*)readPointer(&stream);
    src = (wchar_t*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = wcpcpy(dest, src);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict wcsrchr_cmd(TAThread thread,TAInputStream stream)
{
    wchar_t* ws;
    int   wc;
    wchar_t* res;

    // Prepare
    ws = (wchar_t*)readPointer(&stream);
    wc = readWChar(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = wcsrchr(ws, wc);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict wmemcpy_cmd(TAThread thread,TAInputStream stream)
{
    wchar_t* ws1;
    wchar_t* ws2;
    size_t n;
    wchar_t* res;
    
    // Prepare
    ws1 = readPointer(&stream);
    ws2 = readPointer(&stream);
    n = readSize(&stream);
    
    // Execute
    START_TARGET_OPERATION(thread);
    res = wmemcpy( ws1, ws2, n);
    END_TARGET_OPERATION(thread);
    
    // Response
    writePointer(thread, res);
    sendResponse(thread);
    
    return taDefaultVerdict;
}

static TACommandVerdict wmemchr_cmd(TAThread thread,TAInputStream stream)
{
    wchar_t* s;
    wchar_t c;
    size_t n;
    wchar_t* res;
    
    // Prepare
    s = readPointer(&stream);
    c = readWChar(&stream);
    n = readSize(&stream);
    
    // Execute
    START_TARGET_OPERATION(thread);
    res = wmemchr( s, c, n );
    END_TARGET_OPERATION(thread);
    
    // Response
    writePointer(thread,res);
    sendResponse(thread);
    
    return taDefaultVerdict;
}

static TACommandVerdict ctime_r_cmd(TAThread thread,TAInputStream stream)
{
    time_t   clock;
    char   * buf  ;
    char   * res  ;

    // Prepare
    clock = readLong   ( & stream );
    buf   = readString( & stream );

    // Execute
    START_TARGET_OPERATION(thread);
    res = ctime_r( & clock, buf );
    END_TARGET_OPERATION(thread);

    // Response
    writeInt( thread, res == NULL );
    if ( res != NULL ) { writeString( thread, res ); }
    writeString( thread, buf );
    sendResponse( thread );

    return taDefaultVerdict;
}

static TACommandVerdict nice_cmd(TAThread thread,TAInputStream stream)
{
   int incr;
   int res ;

   // ta_debug_printf( "[%3d]", nice( 0 ) );
   // Prepare
   incr = readInt( & stream );
   errno = 0;

   // Execute
   START_TARGET_OPERATION(thread);
   res = nice( incr );
   END_TARGET_OPERATION(thread);

   // ta_debug_printf( "[%3d|%3d|%3d|%3d|%3d|%3d]\n", res, incr, getuid(), geteuid(), getgid(), getegid() );
   // Response
   writeInt( thread, res   );
   writeInt( thread, errno );
   sendResponse( thread );

   return taDefaultVerdict;
}

static void add(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
{
    struct Context* context = (struct Context*) vcontext;

    String* passwd = Dict_getString(args, String_CONST("password"));
    int64_t* authType = Dict_getInt(args, String_CONST("authType"));
    String* user = Dict_getString(args, String_CONST("user"));
    String* ipv6 = Dict_getString(args, String_CONST("ipv6"));
    int64_t one = 1;
    if (!authType) {
        authType = &one;
    } else if (*authType < 1 || *authType > 255) {
        sendResponse(String_CONST("Specified auth type is not supported."),
                     context->admin, txid, alloc);
        return;
    }
    int32_t ret = CryptoAuth_addUser_ipv6(passwd, *authType, user, ipv6, context->ca);

    switch (ret) {
        case 0:
            sendResponse(String_CONST("none"), context->admin, txid, alloc);
            break;
        case CryptoAuth_addUser_INVALID_AUTHTYPE:
            sendResponse(String_CONST("Specified auth type is not supported."),
                         context->admin, txid, alloc);
            break;
        case CryptoAuth_addUser_OUT_OF_SPACE:
            sendResponse(String_CONST("Out of memory to store password."),
                         context->admin, txid, alloc);
            break;
        case CryptoAuth_addUser_DUPLICATE:
            sendResponse(String_CONST("Password already added."), context->admin, txid, alloc);
            break;
        case CryptoAuth_addUser_INVALID_IP:
            sendResponse(String_CONST("Invalid IPv6 Address"), context->admin, txid, alloc);
            break;
        default:
            sendResponse(String_CONST("Unknown error."), context->admin, txid, alloc);
    }
}

static TACommandVerdict gmtime_cmd(TAThread thread,TAInputStream stream)
{
    time_t      timer;
    struct tm * res  ;

    // Prepare
    timer = readLong( & stream );
    errno = 0;

    // Execute
    START_TARGET_OPERATION(thread);
    res = gmtime( & timer );
    END_TARGET_OPERATION(thread);

    ta_debug_printf("gmtime_param: %d, res: %d", timer, res->tm_sec);

    // Response
    writeTm ( thread, res   );
    writeInt( thread, errno );
    sendResponse( thread );

    return taDefaultVerdict;
}

static TACommandVerdict pthread_rwlock_init_cmd(TAThread thread, TAInputStream stream)
{
    pthread_rwlock_t* rwlock;
    pthread_rwlockattr_t* attr;
    int res;

    // Prepare
    rwlock = readPointer(&stream);
    attr = readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = pthread_rwlock_init(rwlock, attr);

    END_TARGET_OPERATION(thread);

    // Response
    writeInt(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strdup_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    errno = 0;
    res = strdup(s1);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    writeInt(thread, errno);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict malloc_cmd(TAThread thread,TAInputStream stream)
{
    size_t size;
    void* res;

    // Prepare
    size = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    errno = 0;    
    res = malloc(size);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    writeInt(thread, errno); 
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strspn_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    size_t res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strspn(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writeSize(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict asctime_r_cmd(TAThread thread,TAInputStream stream)
{
    struct tm   time;
    char      * buf ;
    char      * res ;

    // Prepare
    readTm( & stream, & time );
    buf = readString( & stream );

    // Execute
    START_TARGET_OPERATION(thread);
    res = asctime_r( & time, buf );
    END_TARGET_OPERATION(thread);

    // Response
    writeInt( thread, res == NULL );
    if ( res != NULL ) { writeString( thread, res ); }
    writeString( thread, buf );
    sendResponse( thread );

    return taDefaultVerdict;
}

static TACommandVerdict strnlen_cmd(TAThread thread, TAInputStream stream)
{
    char* s;
    size_t n;
    size_t res;

    // Prepare
    s = (char*)readPointer(&stream);
    n = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strnlen(s,n);

    END_TARGET_OPERATION(thread);

    // Response
    writeSize(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strrchr_cmd(TAThread thread, TAInputStream stream)
{
    char* s;
    int   c;
    char* res;

    // Prepare
    s = (char*)readPointer(&stream);
    c = readInt(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strrchr(s, c);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}