dnrops
/
radare2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* Initial import RSocket refactor 

- Add SSL client support and testcase
* Update TODO
* Rename some r_hash structs to avoid openssl.h conflict
* io_rap plugin its broken now ... refactor time
This commit is contained in:
earada 2011-03-21 01:47:17 +01:00
parent 44fa1dc253
commit 498e531479
19 changed files with 466 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
TODO
View File

@ -68,10 +68,12 @@ earada
------ ------
* p7 : 7bit encoding (sms) * p7 : 7bit encoding (sms)
* Add print support for bitfields (pm b...) * Add print support for bitfields (pm b...)
* Fix io_haret memory dump
* r_socket * r_socket
- Add SSL support - Add SSL support
- http API in r_socket module - http API in r_socket module
- allow to get/post data/files with continue on plain/ssl - allow to get/post data/files with continue on plain/ssl
* refactor rap and raps
* remove all uses of alloca() // mingw and grep reports them all :) * remove all uses of alloca() // mingw and grep reports them all :)
* typedef all function pointers, like in r_bp * typedef all function pointers, like in r_bp
* Implement case-insensitive search (e search.casematters ?) any better name? Use /i? * Implement case-insensitive search (e search.casematters ?) any better name? Use /i?

20
libr/core/core.c
View File

@ -473,11 +473,12 @@ R_API RAnalOp *r_core_op_anal(RCore *core, ut64 addr) {
// TODO: move into core/io/rap? */ // TODO: move into core/io/rap? */
R_API int r_core_serve(RCore *core, RIODesc *file) { R_API int r_core_serve(RCore *core, RIODesc *file) {
ut8 cmd, flg, *ptr, buf[1024]; ut8 cmd, flg, *ptr, buf[1024];
int i, c, pipefd, fd; int i, pipefd;
ut64 x; ut64 x;
RSocket *c, *fd;
fd = file->fd; fd = (RSocket *)file->data;
if (fd == -1) { if (fd == NULL) {
eprintf ("rap: cannot listen.\n"); eprintf ("rap: cannot listen.\n");
return -1; return -1;
} }
@ -491,14 +492,14 @@ R_API int r_core_serve(RCore *core, RIODesc *file) {
reaccept: reaccept:
core->io->plugin = NULL; core->io->plugin = NULL;
while ((c = r_socket_accept (fd))) { while ((c = r_socket_accept (fd))) {
if (c == -1) { if (c == NULL) {
eprintf ("rap: cannot accept\n"); eprintf ("rap: cannot accept\n");
r_socket_close (c); r_socket_close (c);
return -1; return -1;
} }
eprintf ("rap: client connected\n"); eprintf ("rap: client connected\n");
r_io_accept (core->io, c); r_io_accept (core->io, c->fd);
for (;;) { for (;;) {
i = r_socket_read (c, &cmd, 1); i = r_socket_read (c, &cmd, 1);
if (i==0) { if (i==0) {
@ -557,7 +558,7 @@ reaccept:
r_core_block_size (core, i); r_core_block_size (core, i);
r_mem_copyendian (ptr+1, (ut8 *)&i, 4, !endian); r_mem_copyendian (ptr+1, (ut8 *)&i, 4, !endian);
memcpy (ptr+5, core->block, i); //core->blocksize); memcpy (ptr+5, core->block, i); //core->blocksize);
write (c, ptr, i+5); r_socket_write (c, ptr, i+5);
} }
break; break;
case RMT_CMD: case RMT_CMD:
@ -596,10 +597,10 @@ reaccept:
break; break;
} }
case RMT_WRITE: case RMT_WRITE:
read (c, buf, 5); r_socket_read (c, buf, 5);
r_mem_copyendian((ut8 *)&x, buf+1, 4, endian); r_mem_copyendian((ut8 *)&x, buf+1, 4, endian);
ptr = malloc (x); ptr = malloc (x);
read (c, ptr, x); r_socket_read (c, ptr, x);
r_core_write_at (core, core->offset, ptr, x); r_core_write_at (core, core->offset, ptr, x);
free (ptr); free (ptr);
break; break;
@ -620,7 +621,8 @@ reaccept:
r_socket_read_block (c, buf, 4); r_socket_read_block (c, buf, 4);
r_mem_copyendian ((ut8*)&i, buf, 4, endian); r_mem_copyendian ((ut8*)&i, buf, 4, endian);
{ {
int ret = r_socket_close (i); //FIXME: Use r_socket_close
int ret = close (i);
r_mem_copyendian (buf+1, (ut8*)&ret, 4, !endian); r_mem_copyendian (buf+1, (ut8*)&ret, 4, !endian);
buf[0] = RMT_CLOSE | RMT_REPLY; buf[0] = RMT_CLOSE | RMT_REPLY;
r_socket_write (c, buf, 5); r_socket_write (c, buf, 5);

35
libr/core/rtr.c
View File

@ -23,7 +23,7 @@ R_API void r_core_rtr_pushout(RCore *core, const char *input) {
const char *cmd = NULL; const char *cmd = NULL;
char *str = NULL; char *str = NULL;
if (fd) { if (fd) {
for (rtr_n = 0; rtr_host[rtr_n].fd != fd \ for (rtr_n = 0; rtr_host[rtr_n].fd->fd != fd \
&& rtr_n < RTR_MAX_HOSTS; rtr_n++); && rtr_n < RTR_MAX_HOSTS; rtr_n++);
if (!(cmd = strchr (input, ' '))) { if (!(cmd = strchr (input, ' '))) {
eprintf ("Error\n"); eprintf ("Error\n");
@ -31,7 +31,7 @@ R_API void r_core_rtr_pushout(RCore *core, const char *input) {
} }
} else cmd = input; } else cmd = input;
if (!rtr_host[rtr_n].fd) { if (!rtr_host[rtr_n].fd->fd) {
eprintf("Error: Unknown host\n"); eprintf("Error: Unknown host\n");
return; return;
} }
@ -58,7 +58,7 @@ R_API void r_core_rtr_list(RCore *core) {
int i; int i;
for (i = 0; i < RTR_MAX_HOSTS; i++) for (i = 0; i < RTR_MAX_HOSTS; i++)
if (rtr_host[i].fd) { if (rtr_host[i].fd) {
r_cons_printf("%i - ", rtr_host[i].fd); r_cons_printf("%i - ", rtr_host[i].fd->fd);
if (rtr_host[i].proto == RTR_PROT_TCP) if (rtr_host[i].proto == RTR_PROT_TCP)
r_cons_printf("tcp://"); r_cons_printf("tcp://");
else if (rtr_host[i].proto == RTR_PROT_UDP) else if (rtr_host[i].proto == RTR_PROT_UDP)
@ -71,7 +71,8 @@ R_API void r_core_rtr_list(RCore *core) {
R_API void r_core_rtr_add(RCore *core, const char *_input) { R_API void r_core_rtr_add(RCore *core, const char *_input) {
char input[1024], *host = NULL, *file = NULL, *ptr = NULL, buf[1024]; char input[1024], *host = NULL, *file = NULL, *ptr = NULL, buf[1024];
int proto, port, fd, i; int proto, port, i;
RSocket *fd;
strncpy (input, _input, sizeof (input)-4); strncpy (input, _input, sizeof (input)-4);
/* Parse uri */ /* Parse uri */
@ -108,8 +109,8 @@ R_API void r_core_rtr_add(RCore *core, const char *_input) {
switch (proto) { switch (proto) {
case RTR_PROT_RAP: case RTR_PROT_RAP:
fd = r_socket_connect (host, port); fd = r_socket_new (host, port, R_FALSE); //TODO: Use rap.ssl
if (fd == -1) { if (fd == NULL) {
eprintf ("Error: Cannot connect to '%s' (%d)\n", host, port); eprintf ("Error: Cannot connect to '%s' (%d)\n", host, port);
return; return;
} }
@ -131,16 +132,16 @@ R_API void r_core_rtr_add(RCore *core, const char *_input) {
eprintf ("ok\n"); eprintf ("ok\n");
break; break;
case RTR_PROT_TCP: case RTR_PROT_TCP:
fd = r_socket_connect (host, port); fd = r_socket_new (host, port, R_FALSE); //TODO: Use rap.ssl
if (fd == -1) { if (fd == NULL) {
eprintf ("Error: Cannot connect to '%s' (%d)\n", host, port); eprintf ("Error: Cannot connect to '%s' (%d)\n", host, port);
return; return;
} }
eprintf ("Connected to: %s at port %d\n", host, port); eprintf ("Connected to: %s at port %d\n", host, port);
break; break;
case RTR_PROT_UDP: case RTR_PROT_UDP:
fd = r_socket_udp_connect (host, port); fd = r_socket_udp_connect (host, port, R_FALSE); //TODO: Use rap.ssl
if (fd == -1) { if (fd == NULL) {
eprintf("Error: Cannot connect to '%s' (%d)\n", host, port); eprintf("Error: Cannot connect to '%s' (%d)\n", host, port);
return; return;
} }
@ -168,9 +169,9 @@ R_API void r_core_rtr_remove(RCore *core, const char *input) {
if (input[0] >= '0' && input[0] <= '9') { if (input[0] >= '0' && input[0] <= '9') {
fd = r_num_math (core->num, input); fd = r_num_math (core->num, input);
for (i = 0; i < RTR_MAX_HOSTS; i++) for (i = 0; i < RTR_MAX_HOSTS; i++)
if (rtr_host[i].fd == fd) { if (rtr_host[i].fd->fd == fd) {
r_socket_close (rtr_host[i].fd); r_socket_free (rtr_host[i].fd);
rtr_host[i].fd = 0; rtr_host[i].fd = NULL;
if (rtr_n == i) if (rtr_n == i)
for (rtr_n = 0; !rtr_host[rtr_n].fd && rtr_n < RTR_MAX_HOSTS; rtr_n++); for (rtr_n = 0; !rtr_host[rtr_n].fd && rtr_n < RTR_MAX_HOSTS; rtr_n++);
break; break;
@ -178,7 +179,7 @@ R_API void r_core_rtr_remove(RCore *core, const char *input) {
} else { } else {
for (i = 0; i < RTR_MAX_HOSTS; i++) for (i = 0; i < RTR_MAX_HOSTS; i++)
if (rtr_host[i].fd) if (rtr_host[i].fd)
r_socket_close (rtr_host[i].fd); r_socket_free (rtr_host[i].fd);
memset (rtr_host, '\0', RTR_MAX_HOSTS * sizeof(RCoreRtrHost)); memset (rtr_host, '\0', RTR_MAX_HOSTS * sizeof(RCoreRtrHost));
rtr_n = 0; rtr_n = 0;
} }
@ -190,11 +191,11 @@ R_API void r_core_rtr_session(RCore *core, const char *input) {
if (input[0] >= '0' && input[0] <= '9') { if (input[0] >= '0' && input[0] <= '9') {
fd = r_num_math (core->num, input); fd = r_num_math (core->num, input);
for (rtr_n = 0; rtr_host[rtr_n].fd != fd && rtr_n < RTR_MAX_HOSTS; rtr_n++); for (rtr_n = 0; rtr_host[rtr_n].fd->fd != fd && rtr_n < RTR_MAX_HOSTS; rtr_n++);
} }
for (;;) { for (;;) {
snprintf (prompt, sizeof (prompt), "fd:%d> ", rtr_host[rtr_n].fd); snprintf (prompt, sizeof (prompt), "fd:%d> ", rtr_host[rtr_n].fd->fd);
r_line_singleton ()->prompt = prompt; r_line_singleton ()->prompt = prompt;
if ((r_cons_fgets (buf, sizeof (buf), 0, NULL))) { if ((r_cons_fgets (buf, sizeof (buf), 0, NULL))) {
if (*buf == 'q') if (*buf == 'q')
@ -215,7 +216,7 @@ R_API void r_core_rtr_cmd(RCore *core, const char *input) {
int i, cmd_len, fd = atoi (input); int i, cmd_len, fd = atoi (input);
if (fd != 0) { if (fd != 0) {
for (rtr_n = 0; rtr_host[rtr_n].fd != fd && rtr_n < RTR_MAX_HOSTS; rtr_n++); for (rtr_n = 0; rtr_host[rtr_n].fd->fd != fd && rtr_n < RTR_MAX_HOSTS; rtr_n++);
if (!(cmd = strchr (input, ' '))) { if (!(cmd = strchr (input, ' '))) {
eprintf("Error\n"); eprintf("Error\n");
return; return;

8
libr/hash/sha1.c
View File

@ -38,7 +38,7 @@
#define SHA_ROT(X,n) (((X) << (n)) | ((X) >> (32-(n)))) #define SHA_ROT(X,n) (((X) << (n)) | ((X) >> (32-(n))))
static void shaHashBlock(SHA_CTX *ctx) static void shaHashBlock(R_SHA_CTX *ctx)
{ {
int t; int t;
unsigned int A,B,C,D,E,TEMP; unsigned int A,B,C,D,E,TEMP;
@ -77,7 +77,7 @@ static void shaHashBlock(SHA_CTX *ctx)
ctx->H[4] += E; ctx->H[4] += E;
} }
void SHA1_Init(SHA_CTX *ctx) { void SHA1_Init(R_SHA_CTX *ctx) {
int i; int i;
ctx->lenW = 0; ctx->lenW = 0;
@ -95,7 +95,7 @@ void SHA1_Init(SHA_CTX *ctx) {
ctx->W[i] = 0; ctx->W[i] = 0;
} }
void SHA1_Update(SHA_CTX *ctx, const void *_dataIn, int len) { void SHA1_Update(R_SHA_CTX *ctx, const void *_dataIn, int len) {
const unsigned char *dataIn = _dataIn; const unsigned char *dataIn = _dataIn;
int i; int i;
@ -113,7 +113,7 @@ void SHA1_Update(SHA_CTX *ctx, const void *_dataIn, int len) {
} }
} }
void SHA1_Final(unsigned char hashout[20], SHA_CTX *ctx) void SHA1_Final(unsigned char hashout[20], R_SHA_CTX *ctx)
{ {
unsigned char pad0x80 = 0x80; unsigned char pad0x80 = 0x80;
unsigned char pad0x00 = 0x00; unsigned char pad0x00 = 0x00;

6
libr/hash/sha1.h
View File

@ -42,6 +42,6 @@ typedef struct {
} SHA_CTX; } SHA_CTX;
#endif #endif
void SHA1_Init(SHA_CTX *ctx); void SHA1_Init(R_SHA_CTX *ctx);
void SHA1_Update(SHA_CTX *ctx, const void *dataIn, int len); void SHA1_Update(R_SHA_CTX *ctx, const void *dataIn, int len);
void SHA1_Final(unsigned char hashout[20], SHA_CTX *ctx); void SHA1_Final(unsigned char hashout[20], R_SHA_CTX *ctx);

72
libr/hash/sha2.c
View File

@ -228,9 +228,9 @@ typedef u_int64_t sha2_word64; /* Exactly 8 bytes */
* library -- they are intended for private internal visibility/use * library -- they are intended for private internal visibility/use
* only. * only.
*/ */
void SHA512_Last(SHA512_CTX*); void SHA512_Last(R_SHA512_CTX*);
void SHA256_Transform(SHA256_CTX*, const sha2_word32*); void SHA256_Transform(R_SHA256_CTX*, const sha2_word32*);
void SHA512_Transform(SHA512_CTX*, const sha2_word64*); void SHA512_Transform(R_SHA512_CTX*, const sha2_word64*);
/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/ /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
@ -342,8 +342,8 @@ static const char *sha2_hex_digits = "0123456789abcdef";
/*** SHA-256: *********************************************************/ /*** SHA-256: *********************************************************/
void SHA256_Init(SHA256_CTX* context) { void SHA256_Init(R_SHA256_CTX* context) {
if (context == (SHA256_CTX*)0) { if (context == (R_SHA256_CTX*)0) {
return; return;
} }
MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH); MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
@ -388,7 +388,7 @@ void SHA256_Init(SHA256_CTX* context) {
(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
j++ j++
void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) { void SHA256_Transform(R_SHA256_CTX* context, const sha2_word32* data) {
sha2_word32 a, b, c, d, e, f, g, h, s0, s1; sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
sha2_word32 T1, *W256; sha2_word32 T1, *W256;
int j; int j;
@ -446,7 +446,7 @@ void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
#else /* SHA2_UNROLL_TRANSFORM */ #else /* SHA2_UNROLL_TRANSFORM */
void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) { void SHA256_Transform(R_SHA256_CTX* context, const sha2_word32* data) {
sha2_word32 a, b, c, d, e, f, g, h, s0, s1; sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
sha2_word32 T1, T2, *W256; sha2_word32 T1, T2, *W256;
int j; int j;
@ -526,7 +526,7 @@ void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
#endif /* SHA2_UNROLL_TRANSFORM */ #endif /* SHA2_UNROLL_TRANSFORM */
void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) { void SHA256_Update(R_SHA256_CTX* context, const sha2_byte *data, size_t len) {
unsigned int freespace, usedspace; unsigned int freespace, usedspace;
if (len == 0) { if (len == 0) {
@ -535,7 +535,7 @@ void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
} }
/* Sanity check: */ /* Sanity check: */
assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0); assert(context != (R_SHA256_CTX*)0 && data != (sha2_byte*)0);
usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH; usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
if (usedspace > 0) { if (usedspace > 0) {
@ -574,12 +574,12 @@ void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
usedspace = freespace = 0; usedspace = freespace = 0;
} }
void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) { void SHA256_Final(sha2_byte digest[], R_SHA256_CTX* context) {
sha2_word32 *d = (sha2_word32*)digest; sha2_word32 *d = (sha2_word32*)digest;
unsigned int usedspace; unsigned int usedspace;
/* Sanity check: */ /* Sanity check: */
assert(context != (SHA256_CTX*)0); assert(context != (R_SHA256_CTX*)0);
/* If no digest buffer is passed, we don't bother doing this: */ /* If no digest buffer is passed, we don't bother doing this: */
if (digest != (sha2_byte*)0) { if (digest != (sha2_byte*)0) {
@ -637,12 +637,12 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
usedspace = 0; usedspace = 0;
} }
char *SHA256_End(SHA256_CTX* context, char buffer[]) { char *SHA256_End(R_SHA256_CTX* context, char buffer[]) {
sha2_byte digest[SHA256_DIGEST_LENGTH], *d = digest; sha2_byte digest[SHA256_DIGEST_LENGTH], *d = digest;
int i; int i;
/* Sanity check: */ /* Sanity check: */
assert(context != (SHA256_CTX*)0); assert(context != (R_SHA256_CTX*)0);
if (buffer != (char*)0) { if (buffer != (char*)0) {
SHA256_Final(digest, context); SHA256_Final(digest, context);
@ -661,7 +661,7 @@ char *SHA256_End(SHA256_CTX* context, char buffer[]) {
} }
char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) { char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
SHA256_CTX context; R_SHA256_CTX context;
SHA256_Init(&context); SHA256_Init(&context);
SHA256_Update(&context, data, len); SHA256_Update(&context, data, len);
@ -670,8 +670,8 @@ char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_S
/*** SHA-512: *********************************************************/ /*** SHA-512: *********************************************************/
void SHA512_Init(SHA512_CTX* context) { void SHA512_Init(R_SHA512_CTX* context) {
if (context == (SHA512_CTX*)0) { if (context == (R_SHA512_CTX*)0) {
return; return;
} }
MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH); MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
@ -715,7 +715,7 @@ void SHA512_Init(SHA512_CTX* context) {
(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \ (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
j++ j++
void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) { void SHA512_Transform(R_SHA512_CTX* context, const sha2_word64* data) {
sha2_word64 a, b, c, d, e, f, g, h, s0, s1; sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
sha2_word64 T1, *W512 = (sha2_word64*)context->buffer; sha2_word64 T1, *W512 = (sha2_word64*)context->buffer;
int j; int j;
@ -770,7 +770,7 @@ void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
#else /* SHA2_UNROLL_TRANSFORM */ #else /* SHA2_UNROLL_TRANSFORM */
void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) { void SHA512_Transform(R_SHA512_CTX* context, const sha2_word64* data) {
sha2_word64 a, b, c, d, e, f, g, h, s0, s1; sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
sha2_word64 T1, T2, *W512 = (sha2_word64*)context->buffer; sha2_word64 T1, T2, *W512 = (sha2_word64*)context->buffer;
int j; int j;
@ -848,7 +848,7 @@ void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
#endif /* SHA2_UNROLL_TRANSFORM */ #endif /* SHA2_UNROLL_TRANSFORM */
void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) { void SHA512_Update(R_SHA512_CTX* context, const sha2_byte *data, size_t len) {
unsigned int freespace, usedspace; unsigned int freespace, usedspace;
if (len == 0) { if (len == 0) {
@ -857,7 +857,7 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
} }
/* Sanity check: */ /* Sanity check: */
assert(context != (SHA512_CTX*)0 && data != (sha2_byte*)0); assert(context != (R_SHA512_CTX*)0 && data != (sha2_byte*)0);
usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH; usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
if (usedspace > 0) { if (usedspace > 0) {
@ -896,7 +896,7 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
usedspace = freespace = 0; usedspace = freespace = 0;
} }
void SHA512_Last(SHA512_CTX* context) { void SHA512_Last(R_SHA512_CTX* context) {
unsigned int usedspace; unsigned int usedspace;
usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH; usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
@ -937,11 +937,11 @@ void SHA512_Last(SHA512_CTX* context) {
SHA512_Transform(context, (sha2_word64*)context->buffer); SHA512_Transform(context, (sha2_word64*)context->buffer);
} }
void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) { void SHA512_Final(sha2_byte digest[], R_SHA512_CTX* context) {
sha2_word64 *d = (sha2_word64*)digest; sha2_word64 *d = (sha2_word64*)digest;
/* Sanity check: */ /* Sanity check: */
assert(context != (SHA512_CTX*)0); assert(context != (R_SHA512_CTX*)0);
/* If no digest buffer is passed, we don't bother doing this: */ /* If no digest buffer is passed, we don't bother doing this: */
if (digest != (sha2_byte*)0) { if (digest != (sha2_byte*)0) {
@ -966,12 +966,12 @@ void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
MEMSET_BZERO(context, sizeof(context)); MEMSET_BZERO(context, sizeof(context));
} }
char *SHA512_End(SHA512_CTX* context, char buffer[]) { char *SHA512_End(R_SHA512_CTX* context, char buffer[]) {
sha2_byte digest[SHA512_DIGEST_LENGTH], *d = digest; sha2_byte digest[SHA512_DIGEST_LENGTH], *d = digest;
int i; int i;
/* Sanity check: */ /* Sanity check: */
assert(context != (SHA512_CTX*)0); assert(context != (R_SHA512_CTX*)0);
if (buffer != (char*)0) { if (buffer != (char*)0) {
SHA512_Final(digest, context); SHA512_Final(digest, context);
@ -990,7 +990,7 @@ char *SHA512_End(SHA512_CTX* context, char buffer[]) {
} }
char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) { char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
SHA512_CTX context; R_SHA512_CTX context;
SHA512_Init(&context); SHA512_Init(&context);
SHA512_Update(&context, data, len); SHA512_Update(&context, data, len);
@ -999,8 +999,8 @@ char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_S
/*** SHA-384: *********************************************************/ /*** SHA-384: *********************************************************/
void SHA384_Init(SHA384_CTX* context) { void SHA384_Init(R_SHA384_CTX* context) {
if (context == (SHA384_CTX*)0) { if (context == (R_SHA384_CTX*)0) {
return; return;
} }
MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH); MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
@ -1008,19 +1008,19 @@ void SHA384_Init(SHA384_CTX* context) {
context->bitcount[0] = context->bitcount[1] = 0; context->bitcount[0] = context->bitcount[1] = 0;
} }
void SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) { void SHA384_Update(R_SHA384_CTX* context, const sha2_byte* data, size_t len) {
SHA512_Update((SHA512_CTX*)context, data, len); SHA512_Update((R_SHA512_CTX*)context, data, len);
} }
void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) { void SHA384_Final(sha2_byte digest[], R_SHA384_CTX* context) {
sha2_word64 *d = (sha2_word64*)digest; sha2_word64 *d = (sha2_word64*)digest;
/* Sanity check: */ /* Sanity check: */
assert(context != (SHA384_CTX*)0); assert(context != (R_SHA384_CTX*)0);
/* If no digest buffer is passed, we don't bother doing this: */ /* If no digest buffer is passed, we don't bother doing this: */
if (digest != (sha2_byte*)0) { if (digest != (sha2_byte*)0) {
SHA512_Last((SHA512_CTX*)context); SHA512_Last((R_SHA512_CTX*)context);
/* Save the hash data for output: */ /* Save the hash data for output: */
#if BYTE_ORDER == LITTLE_ENDIAN #if BYTE_ORDER == LITTLE_ENDIAN
@ -1041,12 +1041,12 @@ void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
MEMSET_BZERO(context, sizeof(context)); MEMSET_BZERO(context, sizeof(context));
} }
char *SHA384_End(SHA384_CTX* context, char buffer[]) { char *SHA384_End(R_SHA384_CTX* context, char buffer[]) {
sha2_byte digest[SHA384_DIGEST_LENGTH], *d = digest; sha2_byte digest[SHA384_DIGEST_LENGTH], *d = digest;
int i; int i;
/* Sanity check: */ /* Sanity check: */
assert(context != (SHA384_CTX*)0); assert(context != (R_SHA384_CTX*)0);
if (buffer != (char*)0) { if (buffer != (char*)0) {
SHA384_Final(digest, context); SHA384_Final(digest, context);
@ -1065,7 +1065,7 @@ char *SHA384_End(SHA384_CTX* context, char buffer[]) {
} }
char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) { char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) {
SHA384_CTX context; R_SHA384_CTX context;
SHA384_Init(&context); SHA384_Init(&context);
SHA384_Update(&context, data, len); SHA384_Update(&context, data, len);

48
libr/hash/sha2.h
View File

@ -135,42 +135,42 @@ typedef SHA512_CTX SHA384_CTX;
#ifndef NOPROTO #ifndef NOPROTO
#ifdef SHA2_USE_INTTYPES_H #ifdef SHA2_USE_INTTYPES_H
void SHA256_Init(SHA256_CTX *); void SHA256_Init(R_SHA256_CTX *);
void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t); void SHA256_Update(R_SHA256_CTX*, const uint8_t*, size_t);
void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*); void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], R_SHA256_CTX*);
char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]); char* SHA256_End(R_SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]); char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
void SHA384_Init(SHA384_CTX*); void SHA384_Init(R_SHA384_CTX*);
void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t); void SHA384_Update(R_SHA384_CTX*, const uint8_t*, size_t);
void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*); void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], R_SHA384_CTX*);
char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]); char* SHA384_End(R_SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]); char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
void SHA512_Init(SHA512_CTX*); void SHA512_Init(R_SHA512_CTX*);
void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t); void SHA512_Update(R_SHA512_CTX*, const uint8_t*, size_t);
void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*); void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], R_SHA512_CTX*);
char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]); char* SHA512_End(R_SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]); char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
#else /* SHA2_USE_INTTYPES_H */ #else /* SHA2_USE_INTTYPES_H */
void SHA256_Init(SHA256_CTX *); void SHA256_Init(R_SHA256_CTX *);
void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t); void SHA256_Update(R_SHA256_CTX*, const u_int8_t*, size_t);
void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*); void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], R_SHA256_CTX*);
char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]); char* SHA256_End(R_SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]); char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
void SHA384_Init(SHA384_CTX*); void SHA384_Init(R_SHA384_CTX*);
void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t); void SHA384_Update(R_SHA384_CTX*, const u_int8_t*, size_t);
void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*); void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], R_SHA384_CTX*);
char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]); char* SHA384_End(R_SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]); char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
void SHA512_Init(SHA512_CTX*); void SHA512_Init(R_SHA512_CTX*);
void SHA512_Update(SHA512_CTX*, const u_int8_t*, size_t); void SHA512_Update(R_SHA512_CTX*, const u_int8_t*, size_t);
void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*); void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], R_SHA512_CTX*);
char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]); char* SHA512_End(R_SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]); char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
#endif /* SHA2_USE_INTTYPES_H */ #endif /* SHA2_USE_INTTYPES_H */

3
libr/include/r_core.h
View File

@ -19,6 +19,7 @@
#include "r_flags.h" #include "r_flags.h"
#include "r_config.h" #include "r_config.h"
#include "r_bin.h" #include "r_bin.h"
#include "r_socket.h"
#define R_CORE_CMD_EXIT -2 #define R_CORE_CMD_EXIT -2
#define R_CORE_BLOCKSIZE 64 #define R_CORE_BLOCKSIZE 64
@ -44,7 +45,7 @@ typedef struct r_core_rtr_host_t {
char host[512]; char host[512];
int port; int port;
char file[1024]; char file[1024];
int fd; RSocket *fd;
} RCoreRtrHost; } RCoreRtrHost;
/* rtr */ /* rtr */

16
libr/include/r_hash.h
View File

@ -15,14 +15,14 @@ typedef struct {
unsigned int W[80]; unsigned int W[80];
int lenW; int lenW;
unsigned int sizeHi, sizeLo; unsigned int sizeHi, sizeLo;
} SHA_CTX; } R_SHA_CTX;
#define SHA256_BLOCK_LENGTH 64 #define SHA256_BLOCK_LENGTH 64
typedef struct _SHA256_CTX { typedef struct _SHA256_CTX {
ut32 state[8]; ut32 state[8];
ut64 bitcount; ut64 bitcount;
ut8 buffer[SHA256_BLOCK_LENGTH]; ut8 buffer[SHA256_BLOCK_LENGTH];
} SHA256_CTX; } R_SHA256_CTX;
#define SHA384_BLOCK_LENGTH 128 #define SHA384_BLOCK_LENGTH 128
#define SHA512_BLOCK_LENGTH 128 #define SHA512_BLOCK_LENGTH 128
@ -30,15 +30,15 @@ typedef struct _SHA512_CTX {
ut64 state[8]; ut64 state[8];
ut64 bitcount[2]; ut64 bitcount[2];
ut8 buffer[SHA512_BLOCK_LENGTH]; ut8 buffer[SHA512_BLOCK_LENGTH];
} SHA512_CTX; } R_SHA512_CTX;
typedef SHA512_CTX SHA384_CTX; typedef R_SHA512_CTX R_SHA384_CTX;
typedef struct r_hash_t { typedef struct r_hash_t {
MD5_CTX md5; MD5_CTX md5;
SHA_CTX sha1; R_SHA_CTX sha1;
SHA256_CTX sha256; R_SHA256_CTX sha256;
SHA384_CTX sha384; R_SHA384_CTX sha384;
SHA512_CTX sha512; R_SHA512_CTX sha512;
int rst; int rst;
ut8 digest[128]; ut8 digest[128];
} RHash; } RHash;

58
libr/include/r_socket.h
View File

@ -1,33 +1,39 @@
#ifndef _INCLUDE_SOCKET_H_ #ifndef _INCLUDE_SOCKET_H_
#define _INCLUDE_SOCKET_H_ #define _INCLUDE_SOCKET_H_
#include <openssl/ssl.h>
#include <openssl/err.h>
#include "r_types.h" #include "r_types.h"
/* TODO: major refactoring of r_socket */ typedef struct r_socket_t {
/* make it work like the rest of apis */ int fd;
/* struct r_socket_t *sock = r_socket_new(R_SOCKET_TCP, "gogle.com", 80); */ int is_ssl;
/* struct r_socket_t *sock = r_socket_proc_new(R_SOCKET_PROCESS, "/bin/ls", 80); */ SSL_CTX *ctx;
SSL *sfd;
} RSocket;
#ifdef R_API #ifdef R_API
R_API RSocket *r_socket_new (const char *host, int port, int is_ssl);
R_API void r_socket_free (RSocket *s);
#if __UNIX__ #if __UNIX__
R_API int r_socket_unix_connect(const char *file); R_API RSocket *r_socket_unix_connect (const char *file);
R_API int r_socket_unix_listen(const char *file); R_API int r_socket_unix_listen (const char *file);
#endif #endif
R_API int r_socket_udp_connect(const char *host, int port); R_API int r_socket_connect (const char *host, int port);
R_API int r_socket_flush(int fd); R_API RSocket *r_socket_listen (int port);
R_API void r_socket_block(int fd, int block); R_API void r_socket_block (RSocket *s, int block);
R_API int r_socket_ready(int fd, int secs, int usecs); R_API RSocket *r_socket_accept (RSocket *s);
R_API int r_socket_read(int fd, unsigned char *read, int len); R_API int r_socket_flush (RSocket *s);
R_API int r_socket_read_block(int fd, unsigned char *buf, int len); R_API int r_socket_close (RSocket *s);
R_API int r_socket_puts(int fd, char *buf); R_API int r_socket_ready (RSocket *s, int secs, int usecs);
R_API int r_socket_write(int fd, void *buf, int len); R_API char *r_socket_to_string (RSocket *s);
R_API int r_socket_connect(const char *host, int port); R_API RSocket *r_socket_udp_connect (const char *host, int port, int is_ssl);
R_API int r_socket_listen(int port); R_API int r_socket_write (RSocket *s, void *buf, int len);
R_API int r_socket_accept(int fd); R_API int r_socket_puts (RSocket *s, char *buf);
R_API int r_socket_gets(int fd, char *buf, int size); R_API void r_socket_printf (RSocket *s, const char *fmt, ...);
R_API void r_socket_printf(int fd, const char *fmt, ...); R_API int r_socket_read (RSocket *s, unsigned char *read, int len);
R_API char *r_socket_to_string(int fd); R_API int r_socket_read_block (RSocket *s, unsigned char *buf, int len);
R_API int r_socket_close(int fd); R_API int r_socket_gets (RSocket *s, char *buf, int size);
/* process */ /* process */
typedef struct r_socket_proc_t { typedef struct r_socket_proc_t {
@ -38,11 +44,11 @@ typedef struct r_socket_proc_t {
R_API RSocketProc *r_socket_proc_open(char *const argv[]); R_API RSocketProc *r_socket_proc_open(char *const argv[]);
R_API int r_socket_proc_close(RSocketProc *sp); R_API int r_socket_proc_close(RSocketProc *sp);
#define r_socket_proc_read(x,y,z) r_socket_read(x->fd1[0],y,z) R_API int r_socket_proc_read (RSocketProc *sp, unsigned char *buf, int len);
#define r_socket_proc_gets(x,y,z) r_socket_gets(x->fd1[0],y,z) R_API int r_socket_proc_gets (RSocketProc *sp, char *buf, int size);
#define r_socket_proc_write(x,y,z) r_socket_write(x->fd0[1],y,z) R_API int r_socket_proc_write (RSocketProc *sp, void *buf, int len);
#define r_socket_proc_printf(x,y) r_socket_printf(x->fd0[1],y) R_API void r_socket_proc_printf (RSocketProc *sp, const char *fmt, ...);
#define r_socket_proc_ready(x,y,z) r_socket_ready(x->fd1[0],y,z) R_API int r_socket_proc_ready (RSocketProc *sp, int secs, int usecs);
#endif #endif
#endif #endif

1
libr/include/r_userconf.h.acr
View File

@ -13,6 +13,7 @@
#define R2_VERSION "@VERSION@" #define R2_VERSION "@VERSION@"
#define HAVE_LIB_MAGIC @HAVE_LIB_MAGIC@ #define HAVE_LIB_MAGIC @HAVE_LIB_MAGIC@
#define HAVE_LIB_SSL @HAVE_LIB_SSL@
#define CPU_ENDIAN @BIG_ENDIAN@ #define CPU_ENDIAN @BIG_ENDIAN@

31
libr/io/p/io_haret.c
View File

@ -5,7 +5,7 @@
#include "r_socket.h" #include "r_socket.h"
#include <sys/types.h> #include <sys/types.h>
#define HARET_FD(x) ((int)((size_t)x->data)) #define HARET_FD(x) ((RSocket*)(x->data))
//#if (sizeof(int)) > (sizeof(void*)) //#if (sizeof(int)) > (sizeof(void*))
//#error WTF int>ptr? wrong compiler or architecture? //#error WTF int>ptr? wrong compiler or architecture?
@ -18,11 +18,11 @@ static int haret__write(struct r_io_t *io, RIODesc *fd, const ut8 *buf, int coun
return 0; return 0;
} }
static void haret_wait_until_prompt(int ufd) { static void haret_wait_until_prompt(RSocket *s) {
unsigned char buf; unsigned char buf;
int off = 0; int off = 0;
for (;;) { for (;;) {
if (r_socket_read (ufd, &buf, 1) != 1) { if (r_socket_read (s, &buf, 1) != 1) {
eprintf ("haret_wait_until_prompt: Unexpected eof in socket\n"); eprintf ("haret_wait_until_prompt: Unexpected eof in socket\n");
return; return;
} }
@ -37,32 +37,32 @@ static int haret__read(struct r_io_t *io, RIODesc *fd, ut8 *buf, int count) {
char tmp[1024]; char tmp[1024];
int i = 0; int i = 0;
ut64 off, j; ut64 off, j;
int ufd = HARET_FD (fd); RSocket *s = HARET_FD (fd);
off = io->off & -4; off = io->off & -4;
sprintf (tmp, "pdump 0x%"PFMT64x" %i\r\n", off, count+4); sprintf (tmp, "pdump 0x%"PFMT64x" %i\r\n", off, count+4);
r_socket_write (ufd, tmp, strlen (tmp)); r_socket_write (s, tmp, strlen (tmp));
r_socket_read_block (ufd, (unsigned char *) tmp, strlen (tmp)+1); r_socket_read_block (s, (unsigned char *) tmp, strlen (tmp)+1);
j = (io->off - off)*2; j = (io->off - off)*2;
while (i<count && j >= 0) { while (i<count && j >= 0) {
r_socket_read_block (ufd, (ut8*) tmp, 11); r_socket_read_block (s, (ut8*) tmp, 11);
r_socket_read_block (ufd, (ut8*) tmp, 35); r_socket_read_block (s, (ut8*) tmp, 35);
if (i+16 < count || (io->off-off) == 0) { if (i+16 < count || (io->off-off) == 0) {
tmp[35] = 0; tmp[35] = 0;
i += r_hex_str2bin (tmp+j, buf+i); i += r_hex_str2bin (tmp+j, buf+i);
r_socket_read_block (ufd, (unsigned char *) tmp, 21); r_socket_read_block (s, (unsigned char *) tmp, 21);
} else { } else {
tmp[(io->off - off)*2] = 0; tmp[(io->off - off)*2] = 0;
i += r_hex_str2bin (tmp+j, buf+i); i += r_hex_str2bin (tmp+j, buf+i);
} }
j=0; j=0;
} }
haret_wait_until_prompt (ufd); haret_wait_until_prompt (s);
return i; return i;
} }
static int haret__close(RIODesc *fd) { static int haret__close(RIODesc *fd) {
if (!fd || HARET_FD (fd)==-1) if (!fd || HARET_FD (fd)->fd==-1)
return -1; return -1;
return r_socket_close (HARET_FD (fd)); return r_socket_close (HARET_FD (fd));
} }
@ -73,7 +73,8 @@ static int haret__plugin_open(struct r_io_t *io, const char *pathname) {
static RIODesc *haret__open(struct r_io_t *io, const char *pathname, int rw, int mode) { static RIODesc *haret__open(struct r_io_t *io, const char *pathname, int rw, int mode) {
char *port, *ptr, buf[1024]; char *port, *ptr, buf[1024];
int p, ufd; int p;
RSocket *s;
strncpy (buf, pathname, sizeof (buf)-1); strncpy (buf, pathname, sizeof (buf)-1);
if (haret__plugin_open (io, pathname)) { if (haret__plugin_open (io, pathname)) {
@ -84,12 +85,12 @@ static RIODesc *haret__open(struct r_io_t *io, const char *pathname, int rw, int
} }
*port = 0; *port = 0;
p = atoi (port+1); p = atoi (port+1);
if ((ufd = r_socket_connect (ptr, p)) == -1) { if ((s = r_socket_new (ptr, p, R_FALSE)) == NULL) {
eprintf ("Cannot connect to '%s' (%d)\n", ptr, p); eprintf ("Cannot connect to '%s' (%d)\n", ptr, p);
return NULL; return NULL;
} else eprintf ("Connected to: %s at port %d\n", ptr, p); } else eprintf ("Connected to: %s at port %d\n", ptr, p);
haret_wait_until_prompt (ufd); haret_wait_until_prompt (s);
return r_io_desc_new (&r_io_plugin_haret, ufd, pathname, rw, mode, (void*)(size_t)ufd); return r_io_desc_new (&r_io_plugin_haret, s->fd, pathname, rw, mode, (void*)s);
} }
return NULL; return NULL;
} }

2
libr/print/t/hex.c
View File

@ -8,7 +8,7 @@ int main()
r_cons_new(); r_cons_new();
p = r_print_new(); p = r_print_new();
r_print_hexdump(p, (ut64)(ut32)(main), buf, 128, 16, 1); r_print_hexdump(p, (ut64)(main), buf, 128, 16, 1);
r_cons_flush(); r_cons_flush();
return 0; return 0;

1
libr/socket/Makefile
View File

@ -3,6 +3,7 @@ include ../config.mk
NAME=r_socket NAME=r_socket
#DEPS=r_util #DEPS=r_util
OBJ=socket.o proc.o OBJ=socket.o proc.o
LDFLAGS+=-lssl
# on solaris only # on solaris only
ifeq (${OSTYPE},solaris) ifeq (${OSTYPE},solaris)

44
libr/socket/proc.c
View File

@ -8,6 +8,8 @@
#include <sys/wait.h> #include <sys/wait.h>
#endif #endif
#define BUFFER_SIZE 4096
R_API struct r_socket_proc_t *r_socket_proc_open(char *const argv[]) { R_API struct r_socket_proc_t *r_socket_proc_open(char *const argv[]) {
#if __UNIX__ #if __UNIX__
RSocketProc *sp = R_NEW (RSocketProc); RSocketProc *sp = R_NEW (RSocketProc);
@ -69,3 +71,45 @@ R_API int r_socket_proc_close(struct r_socket_proc_t *sp) {
#endif #endif
return 0; return 0;
} }
R_API int r_socket_proc_read (RSocketProc *sp, unsigned char *buf, int len) {
RSocket s;
s.is_ssl = R_FALSE;
s.fd = sp->fd1[0];
return r_socket_read (&s, buf, len);
}
R_API int r_socket_proc_gets (RSocketProc *sp, char *buf, int size) {
RSocket s;
s.is_ssl = R_FALSE;
s.fd = sp->fd1[0];
return r_socket_gets (&s, buf, size);
}
R_API int r_socket_proc_write (RSocketProc *sp, void *buf, int len) {
RSocket s;
s.is_ssl = R_FALSE;
s.fd = sp->fd0[1];
return r_socket_write (&s, buf, len);
}
R_API void r_socket_proc_printf (RSocketProc *sp, const char *fmt, ...) {
RSocket s;
char buf[BUFFER_SIZE];
va_list ap;
s.is_ssl = R_FALSE;
s.fd = sp->fd0[1];
if (s.fd >= 0) {
va_start (ap, fmt);
vsnprintf (buf, BUFFER_SIZE, fmt, ap);
r_socket_write (&s, buf, strlen(buf));
va_end (ap);
}
}
R_API int r_socket_proc_ready (RSocketProc *sp, int secs, int usecs) {
RSocket s;
s.is_ssl = R_FALSE;
s.fd = sp->fd1[0];
return r_socket_ready (&s, secs, usecs);
}

366
libr/socket/socket.c
View File

@ -26,92 +26,53 @@
#define BUFFER_SIZE 4096 #define BUFFER_SIZE 4096
R_API int r_socket_write(int fd, void *buf, int len) { R_API RSocket *r_socket_new (const char *host, int port, int is_ssl) {
int ret, delta = 0; RSocket *s = R_NEW (RSocket);
for (;;) { s->is_ssl = is_ssl;
ret = send (fd, buf+delta, len, 0); if ((s->fd = r_socket_connect (host, port)) < 0)
if (ret == 0) return NULL;
return -1; if (is_ssl) {
if (ret == len) s->sfd = NULL;
return len; s->ctx = NULL;
if (ret<0) #ifdef HAVE_LIB_SSL
break; if (!SSL_library_init ())
delta += ret; return NULL;
len -= ret; SSL_load_error_strings ();
} s->ctx = SSL_CTX_new (SSLv23_client_method ());
if (ret == -1) if (s->ctx == NULL)
return -1; return NULL;
return delta; s->sfd = SSL_new (s->ctx);
} SSL_set_fd (s->sfd, s->fd);
if (SSL_connect (s->sfd) != 1)
R_API int r_socket_puts(int fd, char *buf) { return NULL;
return r_socket_write (fd, buf, strlen (buf));
}
// XXX: rewrite it to use select //
/* waits secs until new data is received. */
/* returns -1 on error, 0 is false, 1 is true */
R_API int r_socket_ready(int fd, int secs, int usecs) {
#if __UNIX__
int ret;
struct pollfd fds[1];
fds[0].fd = fd;
fds[0].events = POLLIN|POLLPRI;
fds[0].revents = POLLNVAL|POLLHUP|POLLERR;
ret = poll((struct pollfd *)&fds, 1, usecs);
return ret;
#elif __WINDOWS__
fd_set rfds;
struct timeval tv;
int retval;
if (fd==-1)
return -1;
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
tv.tv_sec = secs;
tv.tv_usec = usecs;
if (select (1, &rfds, NULL, NULL, &tv) == -1)
return -1;
return FD_ISSET (0, &rfds);
#else
return R_TRUE; /* always ready if unknown */
#endif #endif
}
R_API void r_socket_block(int fd, int block) {
#if __UNIX__
fcntl (fd, F_SETFL, O_NONBLOCK, !block);
#elif __WINDOWS__
ioctlsocket (fd, FIONBIO, (u_long FAR*)&block);
#endif
}
R_API void r_socket_printf(int fd, const char *fmt, ...) {
char buf[BUFFER_SIZE];
va_list ap;
if (fd >= 0) {
va_start (ap, fmt);
vsnprintf (buf, BUFFER_SIZE, fmt, ap);
r_socket_write (fd, buf, strlen(buf));
va_end (ap);
} }
return s;
}
R_API void r_socket_free (RSocket *s) {
r_socket_close (s);
free (s);
} }
#if __UNIX__ #if __UNIX__
R_API int r_socket_unix_connect(const char *file) { R_API RSocket *r_socket_unix_connect(const char *file) {
RSocket *s = R_NEW (RSocket);
struct sockaddr_un addr; struct sockaddr_un addr;
int sock = socket (PF_UNIX, SOCK_STREAM, 0); int sock = socket (PF_UNIX, SOCK_STREAM, 0);
if (sock <0) if (sock < 0)
return -1; return NULL;
// TODO: set socket options // TODO: set socket options
addr.sun_family = AF_UNIX; addr.sun_family = AF_UNIX;
strncpy (addr.sun_path, file, sizeof(addr.sun_path)); strncpy (addr.sun_path, file, sizeof(addr.sun_path));
if (connect (sock, (struct sockaddr *)&addr, sizeof(addr))==-1) { if (connect (sock, (struct sockaddr *)&addr, sizeof(addr))==-1) {
close (sock); close (sock);
return -1; return NULL;
} }
return sock; s->fd =sock;
s->is_ssl = R_FALSE;
return s;
} }
R_API int r_socket_unix_listen(const char *file) { R_API int r_socket_unix_listen(const char *file) {
@ -180,110 +141,121 @@ R_API int r_socket_connect(const char *host, int port) {
return s; return s;
} }
R_API int r_socket_listen(int port) { R_API RSocket *r_socket_listen(int port) {
int s; RSocket *s;
int fd;
struct sockaddr_in sa; struct sockaddr_in sa;
struct linger linger = { 0 }; struct linger linger = { 0 };
if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP))<0) if ((fd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP))<0)
return -1; return NULL;
linger.l_onoff = 1; linger.l_onoff = 1;
linger.l_linger = 1; linger.l_linger = 1;
setsockopt (s, SOL_SOCKET, SO_LINGER, (const char *) &linger, sizeof (linger)); setsockopt (fd, SOL_SOCKET, SO_LINGER, (const char *) &linger, sizeof (linger));
memset (&sa, 0, sizeof(sa)); memset (&sa, 0, sizeof(sa));
sa.sin_family = AF_INET; sa.sin_family = AF_INET;
sa.sin_addr.s_addr = htonl(INADDR_ANY); sa.sin_addr.s_addr = htonl(INADDR_ANY);
sa.sin_port = htons (port); sa.sin_port = htons (port);
if (bind (s, (struct sockaddr *)&sa, sizeof(sa)) < 0) { if (bind (fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
close (s); close (fd);
return -1; return NULL;
} }
#if __UNIX_ #if __UNIX_
signal (SIGPIPE, SIG_IGN); signal (SIGPIPE, SIG_IGN);
#endif #endif
if (listen (s, 1) < 0) { if (listen (fd, 1) < 0) {
close (s); close (fd);
return -1; return NULL;
} }
s = R_NEW (RSocket);
s->fd = fd;
s->is_ssl = R_FALSE;
return s; return s;
} }
R_API int r_socket_close(int fd) { R_API void r_socket_block(RSocket *s, int block) {
#if __WINDOWS__ #if __UNIX__
WSACleanup (); fcntl (s->fd, F_SETFL, O_NONBLOCK, !block);
return closesocket (fd); #elif __WINDOWS__
#else ioctlsocket (s->fd, FIONBIO, (u_long FAR*)&block);
shutdown (fd, SHUT_RDWR);
return close (fd);
#endif #endif
} }
R_API int r_socket_read_block(int fd, unsigned char *buf, int len) { //TODO: Support SSL
int r, ret = 0; R_API RSocket *r_socket_accept(RSocket *s) {
for (ret=0;ret<len;) { RSocket *sock = R_NEW (RSocket);
r = r_socket_read (fd, buf+ret, len-ret); sock->is_ssl = R_FALSE;
if (r==-1) sock->fd = accept (s->fd, NULL, NULL);
break; return sock;
ret += r;
}
return ret;
} }
R_API int r_socket_read(int fd, unsigned char *buf, int len) { R_API int r_socket_flush(RSocket *s) {
#if __WINDOWS__
return recv (fd, (void *)buf, len, 0);
#else
return read (fd, buf, len);
#endif
}
R_API int r_socket_accept(int fd) {
return accept (fd, NULL, NULL);
}
R_API int r_socket_flush(int fd) {
/* TODO */ /* TODO */
return 0; return 0;
} }
R_API int r_socket_gets(int fd, char *buf, int size) { R_API int r_socket_close(RSocket *s) {
int i = 0; int ret;
int ret = 0;
if (fd == -1) #if __WINDOWS__
return -1; WSACleanup ();
ret = closesocket (s->fd);
while (i<size) { #else
ret = r_socket_read (fd, (ut8 *)buf+i, 1); shutdown (s->fd, SHUT_RDWR);
if (ret==0) ret = close (s->fd);
break; #endif
if (ret<0) { #ifdef HAVE_LIB_SSL
r_socket_close (fd); if (s->is_ssl) {
return i; SSL_shutdown (s->sfd);
} SSL_free (s->sfd);
if (buf[i]=='\r'||buf[i]=='\n') { SSL_CTX_free (s->ctx);
buf[i]='\0';
break;
}
i += ret;
} }
buf[i]='\0'; #endif
return ret;
return i;
} }
R_API char *r_socket_to_string(int fd) { // XXX: rewrite it to use select //
/* waits secs until new data is received. */
/* returns -1 on error, 0 is false, 1 is true */
R_API int r_socket_ready(RSocket *s, int secs, int usecs) {
#if __UNIX__
int ret;
struct pollfd fds[1];
fds[0].fd = s->fd;
fds[0].events = POLLIN|POLLPRI;
fds[0].revents = POLLNVAL|POLLHUP|POLLERR;
ret = poll((struct pollfd *)&fds, 1, usecs);
return ret;
#elif __WINDOWS__
fd_set rfds;
struct timeval tv;
int retval;
if (s->fd==-1)
return -1;
FD_ZERO(&rfds);
FD_SET(s->fd, &rfds);
tv.tv_sec = secs;
tv.tv_usec = usecs;
if (select (1, &rfds, NULL, NULL, &tv) == -1)
return -1;
return FD_ISSET (0, &rfds);
#else
return R_TRUE; /* always ready if unknown */
#endif
}
R_API char *r_socket_to_string(RSocket *s) {
#if __WINDOWS__ #if __WINDOWS__
char *str = malloc (32); char *str = malloc (32);
snprintf (str, sizeof (str), "fd%d", fd); snprintf (str, sizeof (str), "fd%d", s->fd);
return str; return str;
#elif __UNIX__ #elif __UNIX__
char *str = NULL; char *str = NULL;
struct sockaddr sa; struct sockaddr sa;
socklen_t sl = sizeof (sa); socklen_t sl = sizeof (sa);
memset (&sa, 0, sizeof (sa)); memset (&sa, 0, sizeof (sa));
if (!getpeername (fd, &sa, &sl)) { if (!getpeername (s->fd, &sa, &sl)) {
struct sockaddr_in *sain = (struct sockaddr_in*) &sa; struct sockaddr_in *sain = (struct sockaddr_in*) &sa;
ut8 *a = (ut8*) &(sain->sin_addr); ut8 *a = (ut8*) &(sain->sin_addr);
if ((str = malloc (32))) if ((str = malloc (32)))
@ -296,11 +268,14 @@ R_API char *r_socket_to_string(int fd) {
#endif #endif
} }
R_API int r_socket_udp_connect(const char *host, int port) { //XXX: Merge with r_new
R_API RSocket *r_socket_udp_connect(const char *host, int port, int is_ssl) {
struct sockaddr_in sa; struct sockaddr_in sa;
struct hostent *he; struct hostent *he;
int s; int s;
RSocket *sock = R_NEW (RSocket);
sock->is_ssl = is_ssl;
#if __WINDOWS__ #if __WINDOWS__
WSADATA wsadata; WSADATA wsadata;
if (WSAStartup (MAKEWORD (1,1), &wsadata) == SOCKET_ERROR) { if (WSAStartup (MAKEWORD (1,1), &wsadata) == SOCKET_ERROR) {
@ -312,14 +287,14 @@ R_API int r_socket_udp_connect(const char *host, int port) {
#endif #endif
s = socket (AF_INET, SOCK_DGRAM, 0); s = socket (AF_INET, SOCK_DGRAM, 0);
if (s == -1) if (s == -1)
return -1; return NULL;
memset (&sa, 0, sizeof (sa)); memset (&sa, 0, sizeof (sa));
sa.sin_family = AF_INET; sa.sin_family = AF_INET;
he = (struct hostent *)gethostbyname (host); he = (struct hostent *)gethostbyname (host);
if (he == (struct hostent*)0) { if (he == (struct hostent*)0) {
close (s); close (s);
return -1; return NULL;
} }
sa.sin_addr = *((struct in_addr *)he->h_addr); sa.sin_addr = *((struct in_addr *)he->h_addr);
@ -327,8 +302,113 @@ R_API int r_socket_udp_connect(const char *host, int port) {
if (connect (s, (const struct sockaddr*)&sa, sizeof (struct sockaddr))) { if (connect (s, (const struct sockaddr*)&sa, sizeof (struct sockaddr))) {
close (s); close (s);
return -1; return NULL;
} }
sock->fd = s;
return s; if (is_ssl) {
sock->sfd = NULL;
sock->ctx = NULL;
#ifdef HAVE_LIB_SSL
if (!SSL_library_init ())
return NULL;
SSL_load_error_strings ();
sock->ctx = SSL_CTX_new (SSLv23_client_method ());
if (sock->ctx == NULL)
return NULL;
sock->sfd = SSL_new (sock->ctx);
SSL_set_fd (sock->sfd, sock->fd);
if (SSL_connect (sock->sfd) != 1)
return NULL;
#endif
}
return sock;
}
/* Read/Write functions */
R_API int r_socket_write(RSocket *s, void *buf, int len) {
int ret, delta = 0;
for (;;) {
#ifdef HAVE_LIB_SSL
if (s->is_ssl)
ret = SSL_write (s->sfd, buf+delta, len);
else
#endif
ret = send (s->fd, buf+delta, len, 0);
if (ret == 0)
return -1;
if (ret == len)
return len;
if (ret<0)
break;
delta += ret;
len -= ret;
}
if (ret == -1)
return -1;
return delta;
}
R_API int r_socket_puts(RSocket *s, char *buf) {
return r_socket_write (s, buf, strlen (buf));
}
R_API void r_socket_printf(RSocket *s, const char *fmt, ...) {
char buf[BUFFER_SIZE];
va_list ap;
if (s->fd >= 0) {
va_start (ap, fmt);
vsnprintf (buf, BUFFER_SIZE, fmt, ap);
r_socket_write (s, buf, strlen(buf));
va_end (ap);
}
}
R_API int r_socket_read(RSocket *s, unsigned char *buf, int len) {
#ifdef HAVE_LIB_SSL
if (s->is_ssl)
return SSL_read (s->sfd, buf, len);
else
#endif
#if __WINDOWS__
return recv (s->fd, (void *)buf, len, 0);
#else
return read (s->fd, buf, len);
#endif
}
R_API int r_socket_read_block(RSocket *s, unsigned char *buf, int len) {
int r, ret = 0;
for (ret=0;ret<len;) {
r = r_socket_read (s, buf+ret, len-ret);
if (r==-1)
break;
ret += r;
}
return ret;
}
R_API int r_socket_gets(RSocket *s, char *buf, int size) {
int i = 0;
int ret = 0;
if (s->fd == -1)
return -1;
while (i<size) {
ret = r_socket_read (s, (ut8 *)buf+i, 1);
if (ret==0)
break;
if (ret<0) {
r_socket_close (s);
return i;
}
if (buf[i]=='\r'||buf[i]=='\n') {
buf[i]='\0';
break;
}
i += ret;
}
buf[i]='\0';
return i;
} }

4
libr/socket/t/Makefile
View File

@ -1,7 +1,7 @@
include ../../config.mk include ../../config.mk
OBJ=test.o OBJ=testssl.o
BIN=test BIN=testssl
BINDEPS=r_socket BINDEPS=r_socket
include ../../rules.mk include ../../rules.mk

35
libr/socket/t/testls.c
View File

@ -1,23 +1,24 @@
#include <r_socket.h> #include <r_socket.h>
int main() int main() {
{ int ret;
int ret; struct r_socket_proc_t *sp;
struct r_socket_proc_t *sp; char buf[256];
char buf[256]; char *const args[3] = { "/bin/ls", "-l", 0 };
char *const args[3] = { "/bin/ls", "-l", 0 };
sp = r_socket_proc_open(args); sp = r_socket_proc_open(args);
// ret = r_socket_proc_read(sp, buf, 128);
for(;;){ for(;;){
if (!r_socket_proc_ready(sp, 0,0)) if (r_socket_proc_ready(sp, 0,0) < 0)
break; break;
ret = r_socket_proc_fgets(sp, buf, 128); ret = r_socket_proc_gets(sp, buf, 128);
if (ret>0) if (ret>0)
printf("%d=\"%s\"\n", ret, buf); printf("%d=\"%s\"\n", ret, buf);
else break; else {
} printf("%d=\n", ret);
r_socket_proc_close(sp); break;
return 0; }
}
r_socket_proc_close(sp);
return 0;
} }

20
libr/socket/t/testssl.c Normal file
View File

@ -0,0 +1,20 @@
#include <r_socket.h>
#define MAX_LINE 2048
#define SERVER "www.openssl.org"
#define PORT 443
int main (int argc, char ** argv) {
ut8 buf [MAX_LINE+1];
memset (buf, 0, MAX_LINE+1);
RSocket *s = r_socket_new (SERVER, PORT, 1);
if (s == NULL) {
fprintf (stderr, "Error, cannot connect to "SERVER"\n");
return 1;
}
printf ("%i\n",r_socket_puts (s, "GET /\r\n\r\n"));
while(r_socket_read (s, buf, MAX_LINE)>0)
printf ("%s", buf);
r_socket_free (s);
return 0;
}