[libfaim.git] / aim_login.c

/*
 *  aim_login.c
 *
 *  This contains all the functions needed to actually login.
 *
 */

#include "aim.h"


/*
 * FIXME: Reimplement the TIS stuff.
 */
#ifdef TIS_TELNET_PROXY
#include "tis_telnet_proxy.h"
#endif

/*
 *  send_login(int socket, char *sn, char *password)
 *  
 * This is the initial login request packet.
 *
 * The password is encoded before transmition, as per
 * encode_password().  See that function for their
 * stupid method of doing it.
 *
 *
 *
 */
int aim_send_login (struct aim_conn_t *conn, char *sn, char *password, struct client_info_s *clientinfo)
#if 0
{
  char *password_encoded = NULL;  /* to store encoded password */
  int curbyte=0;

  struct command_tx_struct newpacket;

  if (conn)
    newpacket.conn = conn;
  else
    newpacket.conn = aim_getconn_type(AIM_CONN_TYPE_AUTH);

  newpacket.commandlen = 6+2+strlen(sn)+1+1+2+strlen(password)+6;

  if (clientinfo)
    {
      if (strlen(clientinfo->clientstring))
	newpacket.commandlen += strlen(clientinfo->clientstring)+4;
      newpacket.commandlen += 6+6+6; 
      if (strlen(clientinfo->country))
	newpacket.commandlen += strlen(clientinfo->country)+4;
      if (strlen(clientinfo->lang))
	newpacket.commandlen += strlen(clientinfo->lang)+4;
    }

  newpacket.data = (char *) calloc (1,  newpacket.commandlen );
  newpacket.lock = 1;
  newpacket.type = 0x01;

  curbyte += aimutil_put16(newpacket.data+curbyte, 0x0000);
  curbyte += aimutil_put16(newpacket.data+curbyte, 0x0001);
  curbyte += aimutil_put16(newpacket.data+curbyte, 0x0001);
  curbyte += aimutil_put16(newpacket.data+curbyte, strlen(sn));
  curbyte += aimutil_putstr(newpacket.data+curbyte, sn, strlen(sn));

  curbyte += aimutil_put16(newpacket.data+curbyte, 0x0002);
  curbyte += aimutil_put16(newpacket.data+curbyte, strlen(password));
  password_encoded = (char *) malloc(strlen(password));
  aim_encode_password(password, password_encoded);
  curbyte += aimutil_putstr(newpacket.data+curbyte, password_encoded, strlen(password));
  free(password_encoded);
  
  curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x0016, 0x0001);

  if (clientinfo)
    {
      if (strlen(clientinfo->clientstring))
	{
	  curbyte += aimutil_put16(newpacket.data+curbyte, 0x0003);
	  curbyte += aimutil_put16(newpacket.data+curbyte, strlen(clientinfo->clientstring));
	  curbyte += aimutil_putstr(newpacket.data+curbyte, clientinfo->clientstring, strlen(clientinfo->clientstring));
	}
      curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x0017, 0x0001);
      curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x0018, 0x0001);
      curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x001a, 0x0013);
      if (strlen(clientinfo->country))
	{
	  curbyte += aimutil_put16(newpacket.data+curbyte, 0x000e);
	  curbyte += aimutil_put16(newpacket.data+curbyte, strlen(clientinfo->country));
	  curbyte += aimutil_putstr(newpacket.data+curbyte, clientinfo->country, strlen(clientinfo->country));
	}
       if (strlen(clientinfo->lang))
	{
	  curbyte += aimutil_put16(newpacket.data+curbyte, 0x000f);
	  curbyte += aimutil_put16(newpacket.data+curbyte, strlen(clientinfo->lang));
	  curbyte += aimutil_putstr(newpacket.data+curbyte, clientinfo->lang, strlen(clientinfo->lang));
	}
    }

  curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x0009, 0x0015);

  newpacket.lock = 0;
  aim_tx_enqueue(&newpacket);

  return 0;
}
#else
{

  /* this is for the client info field of this packet.  for now, just
     put a few zeros in there and hope they don't notice. */
  char info_field[] = {
    0x00, 0x00, 0x00, 0x00
  };
  int info_field_len = 4;

  char *password_encoded = NULL;  /* to store encoded password */
  int n = 0; /* counter during packet construction */

  struct command_tx_struct newpacket;

  if (conn)
    newpacket.conn = conn;
  else
    newpacket.conn = aim_getconn_type(AIM_CONN_TYPE_AUTH);

  /* breakdown of new_packet_login_len */
  newpacket.commandlen = 6; /* SNAC: fixed bytes */
  newpacket.commandlen += 2; /* SN len */
  newpacket.commandlen += strlen(sn); /* SN text */
  newpacket.commandlen += 1; /* SN null terminator */
  newpacket.commandlen += 1; /* fixed byte */
  newpacket.commandlen += 2; /* password len */
  newpacket.commandlen += strlen(password); /* password text */
  newpacket.commandlen += 1; /* password null term*/
  newpacket.commandlen += 1; /* fixed byte */
  newpacket.commandlen += 2; /* info field len */
  newpacket.commandlen += info_field_len; /* info field text */
  newpacket.commandlen += 1; /* info field null term */
  newpacket.commandlen += 41; /* fixed bytes */

  /* allocate buffer to use for constructing packet_login */
  newpacket.data = (char *) malloc ( newpacket.commandlen );
  memset(newpacket.data, 0x00, newpacket.commandlen);

  newpacket.lock = 1;
  newpacket.type = 0x01;

  newpacket.data[0] = 0x00;
  newpacket.data[1] = 0x00;
  newpacket.data[2] = 0x00;
  newpacket.data[3] = 0x01;
  newpacket.data[4] = 0x00;
  newpacket.data[5] = 0x01;

  newpacket.data[6] = (char) ( (strlen(sn)) >> 8);
  newpacket.data[7] = (char) ( (strlen(sn)) & 0xFF);

  n = 8;
  memcpy(&(newpacket.data[n]), sn, strlen(sn));
  n += strlen(sn);
  newpacket.data[n] = 0x00;
  n++;

  newpacket.data[n] = 0x02;
  n++;

  /* store password length as word */
  newpacket.data[n] = (char) ( (strlen(password)) >> 8);
  newpacket.data[n+1] = (char) ( (strlen(password)) & 0xFF);
  n += 2;

  /* allocate buffer for encoded password */
  password_encoded = (char *) malloc(strlen(password));
  /* encode password */
  aim_encode_password(password, password_encoded);
  /* store encoded password */
  memcpy(&(newpacket.data[n]), password_encoded, strlen(password));

  n += strlen(password);
  /* free buffer */
  free(password_encoded);
  /* place null terminator after encoded password */
  newpacket.data[n] = 0x00;
  n++;

  newpacket.data[n] = 0x03;
  n++;

  newpacket.data[n] = (char) ( (info_field_len) >> 8);
  newpacket.data[n+1] = (char) ( (info_field_len) & 0xFF);
  n += 2;
  memcpy(&(newpacket.data[n]), info_field, info_field_len);
  n += info_field_len;
  newpacket.data[n] = 0x00;
  n++;

  newpacket.data[n] = 0x16;
  newpacket.data[n+1] = 0x00;
  newpacket.data[n+2] = 0x02;
  newpacket.data[n+3] = 0x00;
  n += 4;
  newpacket.data[n] = 0x01;
  newpacket.data[n+1] = 0x00;
  newpacket.data[n+2] = 0x17;
  newpacket.data[n+3] = 0x00;
  n += 4;

  newpacket.data[n] = 0x02;
  newpacket.data[n+1] = 0x00;
  newpacket.data[n+2] = 0x01;
  newpacket.data[n+3] = 0x00;
  n += 4;

  newpacket.data[n] = 0x18;
  newpacket.data[n+1] = 0x00;
  newpacket.data[n+2] = 0x02;
  newpacket.data[n+3] = 0x00;
  n += 4;

  newpacket.data[n] = 0x01;
  newpacket.data[n+1] = 0x00;
  newpacket.data[n+2] = 0x1a;
  newpacket.data[n+3] = 0x00;
  n += 4;

  newpacket.data[n] = 0x02;
  newpacket.data[n+1] = 0x00;
  newpacket.data[n+2] = 0x13;
  newpacket.data[n+3] = 0x00;
  n += 4;

  newpacket.data[n] = 0x0e;
  newpacket.data[n+1] = 0x00;
  newpacket.data[n+2] = 0x02;
  newpacket.data[n+3] = 0x75;
  n += 4;

  newpacket.data[n] = 0x73;
  newpacket.data[n+1] = 0x00;
  newpacket.data[n+2] = 0x0f;
  newpacket.data[n+3] = 0x00;
  n += 4;

  newpacket.data[n] = 0x02;
  newpacket.data[n+1] = 0x65;
  newpacket.data[n+2] = 0x6e;
  newpacket.data[n+3] = 0x00;
  n += 4;
  newpacket.data[n] = 0x09;
  newpacket.data[n+1] = 0x00;
  newpacket.data[n+2] = 0x02;
  newpacket.data[n+3] = 0x00;
  n += 4;

  newpacket.data[n] = 0x15;
  n += 1;

  aim_tx_enqueue(&newpacket);

  return 0;
}
#endif

/*
 *  int encode_password(
 *                      const char *password,
 *	                char *encoded
 *	                ); 
 *
 * This takes a const pointer to a (null terminated) string
 * containing the unencoded password.  It also gets passed
 * an already allocated buffer to store the encoded password.
 * This buffer should be the exact length of the password without
 * the null.  The encoded password buffer IS NOT NULL TERMINATED.
 *
 * The encoding_table seems to be a fixed set of values.  We'll
 * hope it doesn't change over time!  
 *
 */
int aim_encode_password(const char *password, char *encoded)
{
  u_char encoding_table[] = {
    0xf3, 0xb3, 0x6c, 0x99,
    0x95, 0x3f, 0xac, 0xb6,
    0xc5, 0xfa, 0x6b, 0x63,
    0x69, 0x6c, 0xc3, 0x9f
  };

  int i;
  
  for (i = 0; i < strlen(password); i++)
      encoded[i] = (password[i] ^ encoding_table[i]);

  return 0;
}
Commit	Line	Data
9de3ca7e	1	/*
	2	* aim_login.c
	3	*
	4	* This contains all the functions needed to actually login.
	5	*
	6	*/
	7
	8	#include "aim.h"
	9
	10
	11	/*
	12	* FIXME: Reimplement the TIS stuff.
	13	*/
	14	#ifdef TIS_TELNET_PROXY
	15	#include "tis_telnet_proxy.h"
	16	#endif
	17
	18	/*
	19	* send_login(int socket, char sn, char password)
	20	*
	21	* This is the initial login request packet.
	22	*
	23	* The password is encoded before transmition, as per
	24	* encode_password(). See that function for their
	25	* stupid method of doing it.
	26	*
	27	*
	28	*
	29	*/
	30	int aim_send_login (struct aim_conn_t conn, char sn, char password, struct client_info_s clientinfo)
	31	#if 0
	32	{
	33	char password_encoded = NULL; / to store encoded password */
	34	int curbyte=0;
	35
	36	struct command_tx_struct newpacket;
	37
	38	if (conn)
	39	newpacket.conn = conn;
	40	else
	41	newpacket.conn = aim_getconn_type(AIM_CONN_TYPE_AUTH);
	42
	43	newpacket.commandlen = 6+2+strlen(sn)+1+1+2+strlen(password)+6;
	44
	45	if (clientinfo)
	46	{
	47	if (strlen(clientinfo->clientstring))
	48	newpacket.commandlen += strlen(clientinfo->clientstring)+4;
	49	newpacket.commandlen += 6+6+6;
	50	if (strlen(clientinfo->country))
	51	newpacket.commandlen += strlen(clientinfo->country)+4;
	52	if (strlen(clientinfo->lang))
	53	newpacket.commandlen += strlen(clientinfo->lang)+4;
	54	}
	55
	56	newpacket.data = (char *) calloc (1, newpacket.commandlen );
	57	newpacket.lock = 1;
	58	newpacket.type = 0x01;
	59
	60	curbyte += aimutil_put16(newpacket.data+curbyte, 0x0000);
	61	curbyte += aimutil_put16(newpacket.data+curbyte, 0x0001);
	62	curbyte += aimutil_put16(newpacket.data+curbyte, 0x0001);
	63	curbyte += aimutil_put16(newpacket.data+curbyte, strlen(sn));
	64	curbyte += aimutil_putstr(newpacket.data+curbyte, sn, strlen(sn));
65
66	curbyte += aimutil_put16(newpacket.data+curbyte, 0x0002);
67	curbyte += aimutil_put16(newpacket.data+curbyte, strlen(password));
68	password_encoded = (char *) malloc(strlen(password));
69	aim_encode_password(password, password_encoded);
70	curbyte += aimutil_putstr(newpacket.data+curbyte, password_encoded, strlen(password));
71	free(password_encoded);
72
73	curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x0016, 0x0001);
74
75	if (clientinfo)
76	{
77	if (strlen(clientinfo->clientstring))
78	{
79	curbyte += aimutil_put16(newpacket.data+curbyte, 0x0003);
80	curbyte += aimutil_put16(newpacket.data+curbyte, strlen(clientinfo->clientstring));
81	curbyte += aimutil_putstr(newpacket.data+curbyte, clientinfo->clientstring, strlen(clientinfo->clientstring));
82	}
83	curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x0017, 0x0001);
84	curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x0018, 0x0001);
85	curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x001a, 0x0013);
86	if (strlen(clientinfo->country))
87	{
88	curbyte += aimutil_put16(newpacket.data+curbyte, 0x000e);
89	curbyte += aimutil_put16(newpacket.data+curbyte, strlen(clientinfo->country));
90	curbyte += aimutil_putstr(newpacket.data+curbyte, clientinfo->country, strlen(clientinfo->country));
91	}
92	if (strlen(clientinfo->lang))
93	{
94	curbyte += aimutil_put16(newpacket.data+curbyte, 0x000f);
95	curbyte += aimutil_put16(newpacket.data+curbyte, strlen(clientinfo->lang));
96	curbyte += aimutil_putstr(newpacket.data+curbyte, clientinfo->lang, strlen(clientinfo->lang));
97	}
98	}
99
100	curbyte += aim_puttlv_16(newpacket.data+curbyte, 0x0009, 0x0015);
101
102	newpacket.lock = 0;
103	aim_tx_enqueue(&newpacket);
104
105	return 0;
106	}
107	#else
108	{
109
110	/* this is for the client info field of this packet. for now, just
111	put a few zeros in there and hope they don't notice. */
112	char info_field[] = {
113	0x00, 0x00, 0x00, 0x00
114	};
115	int info_field_len = 4;
116
117	char password_encoded = NULL; / to store encoded password */
118	int n = 0; /* counter during packet construction */
119
120	struct command_tx_struct newpacket;
121
122	if (conn)
123	newpacket.conn = conn;
124	else
125	newpacket.conn = aim_getconn_type(AIM_CONN_TYPE_AUTH);
126
127	/* breakdown of new_packet_login_len */
128	newpacket.commandlen = 6; /* SNAC: fixed bytes */
129	newpacket.commandlen += 2; /* SN len */
130	newpacket.commandlen += strlen(sn); /* SN text */
131	newpacket.commandlen += 1; /* SN null terminator */
132	newpacket.commandlen += 1; /* fixed byte */
133	newpacket.commandlen += 2; /* password len */
134	newpacket.commandlen += strlen(password); /* password text */
135	newpacket.commandlen += 1; /* password null term*/
136	newpacket.commandlen += 1; /* fixed byte */
137	newpacket.commandlen += 2; /* info field len */
138	newpacket.commandlen += info_field_len; /* info field text */
139	newpacket.commandlen += 1; /* info field null term */
140	newpacket.commandlen += 41; /* fixed bytes */
141
142	/* allocate buffer to use for constructing packet_login */
143	newpacket.data = (char *) malloc ( newpacket.commandlen );
144	memset(newpacket.data, 0x00, newpacket.commandlen);
145
146	newpacket.lock = 1;
147	newpacket.type = 0x01;
148
149	newpacket.data[0] = 0x00;
150	newpacket.data[1] = 0x00;
151	newpacket.data[2] = 0x00;
152	newpacket.data[3] = 0x01;
153	newpacket.data[4] = 0x00;
154	newpacket.data[5] = 0x01;
155
156	newpacket.data[6] = (char) ( (strlen(sn)) >> 8);
157	newpacket.data[7] = (char) ( (strlen(sn)) & 0xFF);
158
159	n = 8;
160	memcpy(&(newpacket.data[n]), sn, strlen(sn));
161	n += strlen(sn);
162	newpacket.data[n] = 0x00;
163	n++;
164
165	newpacket.data[n] = 0x02;
166	n++;
167
168	/* store password length as word */
169	newpacket.data[n] = (char) ( (strlen(password)) >> 8);
170	newpacket.data[n+1] = (char) ( (strlen(password)) & 0xFF);
171	n += 2;
172
173	/* allocate buffer for encoded password */
174	password_encoded = (char *) malloc(strlen(password));
175	/* encode password */
176	aim_encode_password(password, password_encoded);
177	/* store encoded password */
178	memcpy(&(newpacket.data[n]), password_encoded, strlen(password));
179
180	n += strlen(password);
181	/* free buffer */
182	free(password_encoded);
183	/* place null terminator after encoded password */
184	newpacket.data[n] = 0x00;
185	n++;
186
187	newpacket.data[n] = 0x03;
188	n++;
189
190	newpacket.data[n] = (char) ( (info_field_len) >> 8);
191	newpacket.data[n+1] = (char) ( (info_field_len) & 0xFF);
192	n += 2;
193	memcpy(&(newpacket.data[n]), info_field, info_field_len);
194	n += info_field_len;
195	newpacket.data[n] = 0x00;
196	n++;
197
198	newpacket.data[n] = 0x16;
199	newpacket.data[n+1] = 0x00;
200	newpacket.data[n+2] = 0x02;
201	newpacket.data[n+3] = 0x00;
202	n += 4;
203	newpacket.data[n] = 0x01;
204	newpacket.data[n+1] = 0x00;
205	newpacket.data[n+2] = 0x17;
206	newpacket.data[n+3] = 0x00;
207	n += 4;
208
209	newpacket.data[n] = 0x02;
210	newpacket.data[n+1] = 0x00;
211	newpacket.data[n+2] = 0x01;
212	newpacket.data[n+3] = 0x00;
213	n += 4;
214
215	newpacket.data[n] = 0x18;
216	newpacket.data[n+1] = 0x00;
217	newpacket.data[n+2] = 0x02;
218	newpacket.data[n+3] = 0x00;
219	n += 4;
220
221	newpacket.data[n] = 0x01;
222	newpacket.data[n+1] = 0x00;
223	newpacket.data[n+2] = 0x1a;
224	newpacket.data[n+3] = 0x00;
225	n += 4;
226
227	newpacket.data[n] = 0x02;
228	newpacket.data[n+1] = 0x00;
229	newpacket.data[n+2] = 0x13;
230	newpacket.data[n+3] = 0x00;
231	n += 4;
232
233	newpacket.data[n] = 0x0e;
234	newpacket.data[n+1] = 0x00;
235	newpacket.data[n+2] = 0x02;
236	newpacket.data[n+3] = 0x75;
237	n += 4;
238
239	newpacket.data[n] = 0x73;
240	newpacket.data[n+1] = 0x00;
241	newpacket.data[n+2] = 0x0f;
242	newpacket.data[n+3] = 0x00;
243	n += 4;
244
245	newpacket.data[n] = 0x02;
246	newpacket.data[n+1] = 0x65;
247	newpacket.data[n+2] = 0x6e;
248	newpacket.data[n+3] = 0x00;
249	n += 4;
250	newpacket.data[n] = 0x09;
251	newpacket.data[n+1] = 0x00;
252	newpacket.data[n+2] = 0x02;
253	newpacket.data[n+3] = 0x00;
254	n += 4;
255
256	newpacket.data[n] = 0x15;
257	n += 1;
258
259	aim_tx_enqueue(&newpacket);
260
261	return 0;
262	}
263	#endif
264
265	/*
266	* int encode_password(
267	* const char *password,
268	* char *encoded
269	* );
270	*
271	* This takes a const pointer to a (null terminated) string
272	* containing the unencoded password. It also gets passed
273	* an already allocated buffer to store the encoded password.
274	* This buffer should be the exact length of the password without
275	* the null. The encoded password buffer IS NOT NULL TERMINATED.
276	*
277	* The encoding_table seems to be a fixed set of values. We'll
278	* hope it doesn't change over time!
279	*
280	*/
281	int aim_encode_password(const char password, char encoded)
282	{
283	u_char encoding_table[] = {
284	0xf3, 0xb3, 0x6c, 0x99,
285	0x95, 0x3f, 0xac, 0xb6,
286	0xc5, 0xfa, 0x6b, 0x63,
287	0x69, 0x6c, 0xc3, 0x9f
288	};
289
290	int i;
291
292	for (i = 0; i < strlen(password); i++)
293	encoded[i] = (password[i] ^ encoding_table[i]);
294
295	return 0;
296	}
297
298
299
300