login.c

ncbi源码

    tds->major_version=config->major_version;
    tds->minor_version=config->minor_version;
    tds->emul_little_endian=config->emul_little_endian;
#ifdef WORDS_BIGENDIAN
    if (IS_TDS70(tds) || IS_TDS80(tds)) {
        /* TDS 7/8 only supports little endian */
        tds->emul_little_endian=1;
    }
#endif

    /* set up iconv */
    if (config->client_charset) {
        tds_iconv_open(tds, config->client_charset);
    }

    /* specified a date format? */
    /*
      if (config->date_fmt) {
		tds->date_fmt=strdup(config->date_fmt);
      }
    */
    if (login->connect_timeout) {
        connect_timeout = login->connect_timeout;
    } else if (config->connect_timeout) {
        connect_timeout = config->connect_timeout;
    }

    /* Jeff's hack - begin */
    tds->timeout = (connect_timeout) ? login->query_timeout : 0;        
    tds->longquery_timeout = (connect_timeout) ? login->longquery_timeout : 0;
    tds->longquery_func = login->longquery_func;
    tds->longquery_param = login->longquery_param;
    /* end */

    /* verify that ip_addr is not NULL */
    if (!config->ip_addr) {
        tdsdump_log(TDS_DBG_ERROR, "%L IP address pointer is NULL\n");
        if (config->server_name) {
            tmpstr = malloc(strlen(config->server_name)+100);
            if (tmpstr) {
                sprintf(tmpstr,"Server %s not found!",config->server_name);
                tds_client_msg(tds->tds_ctx, tds, 10019, 9, 0, 0, tmpstr);
                free(tmpstr);
            }
        } else {
            tds_client_msg(tds->tds_ctx, tds, 10020, 9, 0, 0, "No server specified!");
        }
        tds_free_config(config);
        tds_free_socket(tds);
        return NULL;
    }
    sin.sin_addr.s_addr = inet_addr(config->ip_addr);
    if (sin.sin_addr.s_addr == -1) {
        tdsdump_log(TDS_DBG_ERROR, "%L inet_addr() failed, IP = %s\n", config->ip_addr);
        tds_free_config(config);
        tds_free_socket(tds);
        return NULL;
    }

    sin.sin_family = AF_INET;
    sin.sin_port = htons(config->port);

    memcpy(tds->capabilities,login->capabilities,TDS_MAX_CAPABILITY);

    tdsdump_log(TDS_DBG_INFO1, "%L Connecting addr %s port %d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
    if ((tds->s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
        perror ("socket");
        tds_free_config(config);
        tds_free_socket(tds);
        return NULL;
    }

    /* Jeff's hack *** START OF NEW CODE *** */
    if (connect_timeout) {
        start = time (NULL);
        ioctl_blocking = 1; /* ~0; //TRUE; */
        if (IOCTL(tds->s, FIONBIO, &ioctl_blocking) < 0) {
            tds_free_config(config);
            tds_free_socket(tds);
            return NULL;
        }
        retval = connect(tds->s, (struct sockaddr *) &sin, sizeof(sin));
        if (retval < 0 && errno == EINPROGRESS) retval = 0;
        if (retval < 0) {
            tds_client_msg(tds->tds_ctx, tds, 20009, 9, 0, 0, 
                           "Server is unavailable or does not exist.");
            tds_free_config(config);
            tds_free_socket(tds);
            return NULL;
        }
        /* Select on writeability for connect_timeout */
        now = start;
        while ((retval == 0) && ((now-start) < connect_timeout)) {
            FD_SET (tds->s, &fds);
            selecttimeout.tv_sec = connect_timeout - (now-start);
            selecttimeout.tv_usec = 0;
            retval = select(tds->s + 1, NULL, &fds, NULL, &selecttimeout);
            if (retval < 0 && errno == EINTR)
                retval = 0;
            now = time (NULL);
        }

        if ((now-start) > connect_timeout) {
            tds_client_msg(tds->tds_ctx, tds, 20009, 9, 0, 0, 
                           "Server is unavailable or does not exist.");
            tds_free_config(config);
            tds_free_socket(tds);
            return NULL;
        }
    } else {
        if (connect(tds->s, (struct sockaddr *) &sin, sizeof(sin)) <0) {
            char message[128];
            sprintf(message, "src/tds/login.c: tds_connect: %s:%d",
                    inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
            perror(message);
            tds_client_msg(tds->tds_ctx, tds, 20009, 9, 0, 0, 
                           "Server is unavailable or does not exist.");
            tds_free_config(config);
            tds_free_socket(tds);
            return NULL;
        }
    }
    /* END OF NEW CODE */

    if (IS_TDS7_PLUS(tds)) {
        tds->out_flag=0x10;
        tds7_send_login(tds,config);	
    } else {
        tds->out_flag=0x02;
        tds_send_login(tds,config);	
    }
    if (!tds_process_login_tokens(tds)) {
        tds_client_msg(tds->tds_ctx, tds, 20014, 9, 0, 0, 
                       "Login incorrect.");
        tds_free_config(config);
        tds_free_socket(tds);
        tds = NULL;
        return NULL;
    }
    if (tds && config->text_size) {
        sprintf(query,"set textsize %d", config->text_size);
        retval = tds_submit_query(tds,query);
        if (retval == TDS_SUCCEED) {
   			while (tds_process_result_tokens(tds)==TDS_SUCCEED);
        }
    }

    tds->config = NULL;
    tds_free_config(config);
    return tds;
}
#endif
int tds_send_login(TDSSOCKET *tds, TDSCONFIGINFO *config)
{	
    /*   char *tmpbuf;
         int tmplen;*/
#ifdef WORDS_BIGENDIAN
    unsigned char be1[]= {0x02,0x00,0x06,0x04,0x08,0x01};
#endif
    unsigned char le1[]= {0x03,0x01,0x06,0x0a,0x09,0x01};
    unsigned char magic2[]={0x00,0x00};
   
    unsigned char magic3[]= {0x00,0x00,0x00};
   
/* these seem to endian flags as well 13,17 on intel/alpha 12,16 on power */
   
#ifdef WORDS_BIGENDIAN
    unsigned char be2[]= {0x00,12,16};
#endif
    unsigned char le2[]= {0x00,13,17};
   
   /* 
   ** the former byte 0 of magic5 causes the language token and message to be 
   ** absent from the login acknowledgement if set to 1. There must be a way 
   ** of setting this in the client layer, but I am not aware of any thing of
   ** the sort -- bsb 01/17/99
   */
    unsigned char magic5[]= {0x00,0x00};
    unsigned char magic6[]= {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
    unsigned char magic7=   0x01;
   
    unsigned char magic42[]= {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
    unsigned char magic50[]= {0x00,0x00,0x00,0x00};
    /*
** capabilities are now part of the tds structure.
   unsigned char capabilities[]= {0x01,0x07,0x03,109,127,0xFF,0xFF,0xFF,0xFE,0x02,0x07,0x00,0x00,0x0A,104,0x00,0x00,0x00};
*/
/*
** This is the original capabilities packet we were working with (sqsh)
   unsigned char capabilities[]= {0x01,0x07,0x03,109,127,0xFF,0xFF,0xFF,0xFE,0x02,0x07,0x00,0x00,0x0A,104,0x00,0x00,0x00};
** original with 4.x messages
   unsigned char capabilities[]= {0x01,0x07,0x03,109,127,0xFF,0xFF,0xFF,0xFE,0x02,0x07,0x00,0x00,0x00,120,192,0x00,0x0D};
** This is isql 11.0.3
   unsigned char capabilities[]= {0x01,0x07,0x00,96, 129,207, 0xFF,0xFE,62,  0x02,0x07,0x00,0x00,0x00,120,192,0x00,0x0D};
** like isql but with 5.0 messages
   unsigned char capabilities[]= {0x01,0x07,0x00,96, 129,207, 0xFF,0xFE,62,  0x02,0x07,0x00,0x00,0x00,120,192,0x00,0x00};
**
*/
   
    unsigned char protocol_version[4];
    unsigned char program_version[4];
   
    int rc;
    char blockstr[10], passwdstr[255];
   
    if (IS_TDS42(tds)) {
        memcpy(protocol_version,"\004\002\000\000",4);
        memcpy(program_version,"\004\002\000\000",4);
    } else if (IS_TDS46(tds)) {
        memcpy(protocol_version,"\004\006\000\000",4);
        memcpy(program_version,"\004\002\000\000",4);
    } else if (IS_TDS50(tds)) {
        memcpy(protocol_version,"\005\000\000\000",4);
        memcpy(program_version,"\005\000\000\000",4);
    } else {
        tdsdump_log(TDS_DBG_SEVERE,"Unknown protocol version!\n");
        exit(1);
    }
    /*
   ** the following code is adapted from  Arno Pedusaar's 
   ** ([e-mail]) MS-SQL Client. His was a much better way to
   ** do this, (well...mine was a kludge actually) so here's mostly his
   */
   
    rc=tds_put_string(tds,config->host_name,TDS_MAX_LOGIN_STR_SZ);   /* client host name */
    rc|=tds_put_string(tds,config->user_name,TDS_MAX_LOGIN_STR_SZ);  /* account name */
    rc|=tds_put_string(tds,config->password,TDS_MAX_LOGIN_STR_SZ);  /* account password */
    //rc|=tds_put_string(tds,"37876",TDS_MAX_LOGIN_STR_SZ);        /* host process */
    rc|=tds_put_string(tds,"11111",TDS_MAX_LOGIN_STR_SZ);        /* host process */
#ifdef WORDS_BIGENDIAN
    if (tds->emul_little_endian) {
        rc|=tds_put_n(tds,le1,6);
    } else {
        rc|=tds_put_n(tds,be1,6);
    }
#else
    rc|=tds_put_n(tds,le1,6);
#endif
    rc|=tds_put_byte(tds,config->bulk_copy);
    rc|=tds_put_n(tds,magic2,2);
    if (IS_TDS42(tds)) {
        rc|=tds_put_int(tds,512);
    } else {
        rc|=tds_put_int(tds,0);
    }
    rc|=tds_put_n(tds,magic3,3);
    rc|=tds_put_string(tds,config->app_name,TDS_MAX_LOGIN_STR_SZ);
    rc|=tds_put_string(tds,config->server_name,TDS_MAX_LOGIN_STR_SZ);
    if (IS_TDS42(tds)) {
        rc|=tds_put_string(tds,config->password,255);
    } else {
        if(config->password == NULL) {
            sprintf(passwdstr, "%c%c%s", 0, 0, "");
            rc|=tds_put_buf(tds,passwdstr,255,(unsigned char)2);
        } else {
            sprintf(passwdstr,"%c%c%s",0,
                    (unsigned char)strlen(config->password),
                    config->password);
            rc|=tds_put_buf(tds,passwdstr,255,(unsigned char)strlen(config->password)+2);
        }
    }
   
    rc|=tds_put_n(tds,protocol_version,4); /* TDS version; { 0x04,0x02,0x00,0x00 } */
    rc|=tds_put_string(tds,config->library,10);  /* client program name */
    if (IS_TDS42(tds)) { 
        rc|=tds_put_int(tds,0);
    } else {
        rc|=tds_put_n(tds,program_version,4); /* program version ? */
    }
#ifdef WORDS_BIGENDIAN
    if (tds->emul_little_endian) {
        rc|=tds_put_n(tds,le2,3);
    } else {
        rc|=tds_put_n(tds,be2,3);
    }
#else
    rc|=tds_put_n(tds,le2,3);
#endif
    rc|=tds_put_string(tds,config->language,TDS_MAX_LOGIN_STR_SZ);  /* language */
    rc|=tds_put_byte(tds,config->suppress_language);
    rc|=tds_put_n(tds,magic5,2);
    rc|=tds_put_byte(tds,config->encrypted);
    rc|=tds_put_n(tds,magic6,10);
    rc|=tds_put_string(tds,config->char_set,TDS_MAX_LOGIN_STR_SZ);  /* charset */
    rc|=tds_put_byte(tds,magic7);
    sprintf(blockstr,"%d",config->block_size);
    rc|=tds_put_string(tds,blockstr,6); /* network packet size */
    if (IS_TDS42(tds)) {
        rc|=tds_put_n(tds,magic42,8);
    } else if (IS_TDS46(tds)) {
        rc|=tds_put_n(tds,magic42,4);
    } else if (IS_TDS50(tds)) {
        rc|=tds_put_n(tds,magic50,4);
        rc|=tds_put_byte(tds, TDS_CAP_TOKEN);
        rc|=tds_put_smallint(tds, 18);
        rc|=tds_put_n(tds,tds->capabilities,TDS_MAX_CAPABILITY);
    }
   
    /*
   tmpbuf = malloc(tds->out_pos);
   tmplen = tds->out_pos;
   memcpy(tmpbuf, tds->out_buf, tmplen);
   tdsdump_off();
*/
    rc|=tds_flush_packet(tds);
    /*
   tdsdump_on();
   tdsdump_log(TDS_DBG_NETWORK, "Sending packet (passwords supressed)@ %L\n%D\n", tmpbuf, tmplen);
   free(tmpbuf);
*/
   /* get_incoming(tds->s); */
    return 0;
}


int tds7_send_auth(TDSSOCKET *tds, unsigned char *challenge)
{
#if DOMAIN
    int rc;
    int current_pos;
    TDSANSWER answer;

    /* FIXME: stuff duplicate in tds7_send_login */
    const char* domain;
    const char* user_name;
    const char* p;
    int user_name_len;
    int host_name_len;
    int password_len;
    int domain_len;
    unsigned char unicode_string[256];

    TDSCONFIGINFO *config = tds->config;

    /* check config */
    if (!config)
        return TDS_FAIL;

    /* parse a bit of config */
    domain = config->default_domain;
    user_name = config->user_name;
    user_name_len = user_name ? strlen(user_name) : 0;
    host_name_len = config->host_name ? strlen(config->host_name) : 0;
    password_len = config->password ? strlen(config->password) : 0;
    domain_len = domain ? strlen(domain) : 0;
	
    /* check override of domain */
    if (user_name && (p=strchr(user_name,'\\')) != NULL)
        {
            domain = user_name;
            domain_len = p-user_name;
		
            user_name = p+1;
            user_name_len = strlen(user_name);
        }

    tds->out_flag=0x11;
    tds_put_n(tds, "NTLMSSP", 8);
    tds_put_int(tds, 3); /* sequence 3 */