File rgfs.c changed (mode: 100644) (index 8ea9802..39d0b0d) |
... |
... |
static ssize_t rgfs_ws1(void) |
188 |
188 |
return rgfs_send("ws req", out, len); |
return rgfs_send("ws req", out, len); |
189 |
189 |
} |
} |
190 |
190 |
|
|
|
191 |
|
/* |
|
192 |
|
* Send a generic variable |
|
193 |
|
*/ |
|
194 |
|
static int rgfs_send_gen_var(const char *var, const char *value) |
|
195 |
|
{ |
|
196 |
|
unsigned int len_var, len_value, i; |
|
197 |
|
unsigned char buf[4096]; |
|
198 |
|
|
|
199 |
|
xlog("Sending generic var [%s]=[%s]...\n", var, value); |
|
200 |
|
len_var = strlen(var); |
|
201 |
|
len_value = strlen(value); |
|
202 |
|
|
|
203 |
|
if (1 + 2 + 2 + 2 + len_var + len_value > sizeof(buf)) { |
|
204 |
|
xlog("Buffer is too small to send generic var!\n"); |
|
205 |
|
return -1; |
|
206 |
|
} |
|
207 |
|
|
|
208 |
|
i = 0; |
|
209 |
|
buf[i++] = 0x12; // type=genvar |
|
210 |
|
buf[i++] = (2 + 2 + len_var + len_value) >> 8; // len H |
|
211 |
|
buf[i++] = 2 + 2 + len_var + len_value; // len L |
|
212 |
|
buf[i++] = len_var >> 8; |
|
213 |
|
buf[i++] = len_var; |
|
214 |
|
buf[i++] = len_value >> 8; |
|
215 |
|
buf[i++] = len_value; |
|
216 |
|
memcpy(buf + i, var, len_var); i += len_var; |
|
217 |
|
memcpy(buf + i, value, len_value); i += len_value; |
|
218 |
|
return rgfs_send(var, buf, i); |
|
219 |
|
} |
|
220 |
|
|
191 |
221 |
/* |
/* |
192 |
222 |
* Returns 0 if ok, 1 if we should abort the program else => retry. |
* Returns 0 if ok, 1 if we should abort the program else => retry. |
193 |
223 |
*/ |
*/ |
|
... |
... |
static int rgfs_tls(void) |
347 |
377 |
} |
} |
348 |
378 |
|
|
349 |
379 |
if (rgfs_uid) { |
if (rgfs_uid) { |
350 |
|
xlog("Sending uid...\n"); |
|
351 |
|
len = strlen(rgfs_uid); |
|
352 |
|
buf[0] = 0x12; // type=genvar |
|
353 |
|
buf[1] = (2 + 2 + 3 + len) >> 8; // len H |
|
354 |
|
buf[2] = 2 + 2 + 3 + len; // len L |
|
355 |
|
buf[3] = 0; // strlen("uid") |
|
356 |
|
buf[4] = 3; // strlen("uid") |
|
357 |
|
buf[5] = len >> 8; |
|
358 |
|
buf[6] = len; |
|
359 |
|
memcpy(buf + 7, "uid", 3); |
|
360 |
|
memcpy(buf + 7 + 3, rgfs_uid, len); |
|
361 |
|
r = rgfs_send("uid", buf, 7 + 3 + len); |
|
|
380 |
|
r = rgfs_send_gen_var("uid", rgfs_uid); |
362 |
381 |
if (r <= 0) |
if (r <= 0) |
363 |
382 |
break; |
break; |
364 |
|
ret = 0; |
|
365 |
383 |
} |
} |
366 |
384 |
|
|
367 |
385 |
if (rgfs_repo_id) { |
if (rgfs_repo_id) { |
368 |
|
xlog("Sending repo_id...\n"); |
|
369 |
|
len = strlen(rgfs_repo_id); |
|
370 |
|
buf[0] = 0x12; // type=genvar |
|
371 |
|
buf[1] = (2 + 2 + 7 + len) >> 8; // len H |
|
372 |
|
buf[2] = 2 + 2 + 7 + len; // len L |
|
373 |
|
buf[3] = 0; // strlen("repo_id") |
|
374 |
|
buf[4] = 7; // strlen("repo_id") |
|
375 |
|
buf[5] = len >> 8; |
|
376 |
|
buf[6] = len; |
|
377 |
|
memcpy(buf + 7, "repo_id", 7); |
|
378 |
|
memcpy(buf + 7 + 7, rgfs_repo_id, len); |
|
379 |
|
r = rgfs_send("repo_id", buf, 7 + 7 + len); |
|
|
386 |
|
r = rgfs_send_gen_var("repo_id", rgfs_repo_id); |
380 |
387 |
if (r <= 0) |
if (r <= 0) |
381 |
388 |
break; |
break; |
382 |
|
ret = 0; |
|
383 |
389 |
} |
} |
384 |
390 |
|
|
385 |
391 |
if (rgfs_head) { |
if (rgfs_head) { |
386 |
|
xlog("Sending head...\n"); |
|
387 |
|
len = strlen(rgfs_head); |
|
388 |
|
buf[0] = 0x12; // type=genvar |
|
389 |
|
buf[1] = (2 + 2 + 4 + len) >> 8; // len H |
|
390 |
|
buf[2] = 2 + 2 + 4 + len; // len L |
|
391 |
|
buf[3] = 0; // strlen("head") |
|
392 |
|
buf[4] = 4; // strlen("head") |
|
393 |
|
buf[5] = len >> 8; |
|
394 |
|
buf[6] = len; |
|
395 |
|
memcpy(buf + 7, "head", 4); |
|
396 |
|
memcpy(buf + 7 + 4, rgfs_head, len); |
|
397 |
|
r = rgfs_send("head", buf, 7 + 4 + len); |
|
|
392 |
|
r = rgfs_send_gen_var("head", rgfs_head); |
398 |
393 |
if (r <= 0) |
if (r <= 0) |
399 |
394 |
break; |
break; |
400 |
|
ret = 0; |
|
401 |
395 |
} |
} |
|
396 |
|
|
|
397 |
|
ret = 0; |
402 |
398 |
} while (0); |
} while (0); |
403 |
399 |
|
|
404 |
400 |
return ret; |
return ret; |