s5authlib.c

ss5的socks5认扩展认证模块,实现了基本了认证功能,需要的话,可以进行功能增强扩展. 已在Linux下测试通过.

    
} /* End of db_next */

void db_close()
{
    mysql_close(&db_conn);
} /* End of db_close */


void load_s5_user(const char *name_str)
{
    char sql[256];
    void *db_result;
    char **db_row;

    if (!name_str)
        return ;
    
    if (STRCEQ(name_str, "all"))
    {
        sprintf(sql, "SELECT `u_name`,`u_passwd` FROM `s5_user`");
    }
    else
    {
        sprintf(sql, "SELECT `u_name`,`u_passwd` FROM `s5_user` WHERE `u_name`='%s'", name_str);
    }

    db_result = db_query(sql);
    while ((db_row = (char **)db_next(db_result)))
    {
        int col=0;
        AuthUser *ptrUser;
        AuthUser sUser;

        memset(&sUser, 0, sizeof(AuthUser));

        if (db_row[col])
            sprintf(sUser.UserName, "%s", db_row[col]);
        else
            continue;

        col++;
        if (db_row[col])
            sprintf(sUser.PassWord, "%s", db_row[col]);
        else
            continue;

        ptrUser = add_auth_user(&sUser);
        
    }

    
} /* End of load_s5_user */

static AuthCode S5AuthAccept(struct sockaddr_in *clientSsin, int *clientSocket)
{

    socklen_t len;
    
    len = sizeof(struct sockaddr_in);
    
    if(((*clientSocket) = (int)accept(S5AuthSocket, (struct sockaddr *)clientSsin, &len)) == -1 )
    {
        return AuthFalse;
    }

    return AuthTrue;

} /* End of S5AuthAccept */

static AuthUser *proc_login(const char *name, const char *passwd, int *errno)
{
    AuthUser *sUser;

    //#ifdef HASH_AUTH_MODE
    if (S5AuthConf.auth_mode == AUTH_HASH_MODE)
    {
        BINT4 index;
        index = AuthNameHash(name, MAX_USER_TBL);
    #ifdef MAIN_DEBUG_INFO
        printf("File [%s], line [%d], Index [%lu]\n",__FILE__, __LINE__, index);
    #endif
        
        sUser = authUserTbl[index];

        while (sUser)
        {
            if (STRCEQ(sUser->UserName, name))
            {
                if (STRCEQ(sUser->PassWord, passwd))
                {
                    //*errno =
                    return sUser;
                }
                else
                {
                    *errno = ERROR_PASSWORD_INCORRECT;
                    return NULL;
                }
            }
            sUser = sUser->next;
        }
    //#else
    }
    else
    {
        char sql[128];
        void *db_result;
        char **db_row;
        
        sprintf(sql, "SELECT `u_name`,`u_passwd` FROM `s5_user` WHERE `u_name`='%s' AND `u_passwd`='%s'", name, passwd);
        printf("Sql [%s]\n", sql);

        db_result = db_query(sql);
        while ((db_row = (char **)db_next(db_result)))
        {
            int col=0;

            sUser = (AuthUser *)calloc(1, sizeof(AuthUser));
            
            if (db_row[col])
                sprintf(sUser->UserName, "%s", db_row[col]);
            else
                return NULL;

            col++;
            if (db_row[col])
                sprintf(sUser->PassWord, "%s", db_row[col]);
            else
                return NULL;

            return sUser;

                
        }
    //#endif
    }

    *errno = ERROR_ACCOUNT_NOT_FOUND;
    
    return NULL;
    
} /* End of proc_login */

static int proc_auth_mesg(char *ptrmesg, char *retMesg)
{
    int   retMesg_len = 0;
    int   errno = 0;
    BINT2 auth_opt;
    BINT1 auth_name_len;
    BINT1 auth_passwd_len;

    AuthUser *tUser;

    char auth_name[MAX_NAME_LEN]     = {0};
    char auth_passwd[MAX_PASSWD_LEN] = {0};
    
    if (!ptrmesg)
        return AuthFalse;
    
#ifdef MAIN_DEBUG_INFO
    printf("File [%s]\t=> line [%d], Auth Mesg [%s]\n", __FILE__, __LINE__, ptrmesg);
#endif

    memcpy(&auth_opt, ptrmesg, AUTH_OPTION_SIZE);
    ptrmesg += AUTH_OPTION_SIZE;

    switch (auth_opt)
    {
        //This is user login
        case AUTH_LOGIN:
        {
            //get auth user name length
            memcpy(&auth_name_len, ptrmesg, AUTH_NAME_LEN_SIZE);
            ptrmesg += AUTH_NAME_LEN_SIZE;
            
            //get auth user name
            memcpy(auth_name, ptrmesg, auth_name_len);
            if (auth_name[0] == '\0')
            {
                retMesg_len = sprintf(retMesg, "%s,%d\n", CMD_OK, ERROR_CMD_NAME_NULL);
                return retMesg_len;
            }
            ptrmesg += auth_name_len;
            
            //get user password length
            memcpy(&auth_passwd_len, ptrmesg, AUTH_PASSWD_LEN_SIZE);
            ptrmesg += AUTH_PASSWD_LEN_SIZE;
            
            //get user password
            memcpy(auth_passwd, ptrmesg, auth_passwd_len);

            printf("Auth Opt [%d], User [%s], Passwd [%s]\n", auth_opt, auth_name, auth_passwd);

            tUser = proc_login(auth_name, auth_passwd, &errno);

            if (tUser != NULL)
            {
                retMesg_len = sprintf(retMesg, "%s\n", CMD_OK);
            }
            else
            {
                retMesg_len = sprintf(retMesg, "%s,%d\n", CMD_ERROR, errno);
            }
            
            
        }
        break;

        //This is user logout
        case AUTH_LOGOUT:
        break;

        case AUTH_CANCEL:
        break;

        default:
            retMesg_len = sprintf(retMesg, "%s,%d\n", CMD_OK, ERROR_CMD_NAME_NULL);
            return retMesg_len;
        break;
    }

    printf("Auth option [%d]\n", auth_opt);

    return retMesg_len;
    
    
} /* End of proc_recv */


static void auth_server_thread(void *para)
{

    struct timeval tv;
    struct sockaddr_in clientSsin;
    int    clientSocket;
    int    selt, i;
    int    recv_len;
    int    retMesg_len = 0;
    fd_set rset, allset;
    int    client[MAX_CONNICTION]       = {0};
    char   recv_buffer[MAX_BUFFER_SIZE] = {0};
    char   retMesg[MAX_BUFFER_SIZE]     = {0};

    tv.tv_sec  = 5;   //s
    tv.tv_usec = 0;   //ms

    FD_ZERO(&allset);
    FD_SET(S5AuthSocket, &allset);
    while (AuthTrue)
    {   

        rset = allset;
        tv.tv_sec  = 5;   //s
        tv.tv_usec = 0;   //ms

        selt = select(FD_SETSIZE, &rset, NULL, NULL, &tv);
        if (selt < 0 )
        {
            continue;
        }

        if (FD_ISSET(S5AuthSocket, &rset))
        {
            S5AuthAccept(&clientSsin, &clientSocket);
            for (i=0; i<MAX_CONNICTION; i++)
            {
                if (client[i] <= 0)
                {
                #ifdef MAIN_DEBUG_INFO
                    printf("File [%s]\t=>line [%d], Add socket [%d] to array [%d]\n", __FILE__, __LINE__, clientSocket, i);
                #endif
                    client[i] = clientSocket;
                    FD_SET(clientSocket, &allset);
                    break;
                }
            }
            if (i >= MAX_CONNICTION)
                close(clientSocket);
        }

        for (i=0; i<MAX_CONNICTION; i++)
        {
            if (client[i] <= 0)
            {
                continue;
            }
            
            if (FD_ISSET(client[i], &rset))
            {
                memset(recv_buffer, 0, sizeof(recv_buffer));
                recv_len = recv(client[i], recv_buffer, MAX_BUFFER_SIZE, 0);

                if (recv_len > 0)
                {
                    //printf("Recv [%s]\n", recv_buffer);
                    
                    if (recv_len <= MAX_AUTH_CMD_LEN)
                    {
                        if (recv_buffer[recv_len-1] == ';')
                        {
                            //retMesg_len = sprintf(retMesg, "%s\n", CMD_OK);

                            retMesg_len = proc_auth_mesg(recv_buffer, retMesg);

                            if (retMesg_len == AuthFalse)
                                continue;
                            
                            goto send_mesg;

                            
                        }
                        else
                        {
                            retMesg_len = sprintf(retMesg, "%s,%d\n", CMD_ERROR, ERROR_CMD_NOT_TAIL);
                            goto send_mesg;
                        }
                    }
                    else
                    {
                        retMesg_len = sprintf(retMesg, "%s,%d\n", CMD_ERROR, ERROR_CMD_TOO_LONG);
                        goto send_mesg;
                    }
                }
                else
                {
                    FD_CLR(client[i], &allset);
                    close(client[i]);
                    client[i] = 0;
                }


                send_mesg:
                #ifdef MAIN_DEBUG_INFO
                    printf("Send len [%d]\n", retMesg_len);
                #endif
                    send(client[i], retMesg, retMesg_len, 0);
                
            }

        }

    }

} /* End of auth_server_thread */


AuthBool init_auth_server_thread()
{

    
    AuthCode socket_sts;

    //Create main socket for s5auth server
    socket_sts = S5AuthServerMake(S5AuthConf.auth_addr, S5AuthConf.auth_port);

#ifdef MAIN_DEBUG_INFO
    printf("Socket status [%d], Socket [%d]\n", socket_sts, S5AuthSocket);
#endif

    if (!socket_sts)
        return AuthFalse;

    if (pthread_create(&auth_server_thread_id, NULL, (void *)&auth_server_thread, NULL))
    {
        return AuthFalse;
    }

    return AuthTrue;
    
} /* End of init_auth_server_thread */


void shut_auth_server_thread()
{
    if (auth_server_thread_id)
    {
        pthread_cancel(auth_server_thread_id);
        auth_server_thread_id = 0;
    }
} /* End of shut_auth_server_thread */