commit 75106a26b4ef8167406cd4d457c24e4aa6618118
Author: rl1987 <rl1987(a)sdf.lonestar.org>
Date: Wed May 16 14:47:46 2018 +0200
Fix type in socks5.trunnel
---
src/trunnel/socks5.c | 48 ++++++++++++++++++++++----------------------
src/trunnel/socks5.h | 50 +++++++++++++++++++++++-----------------------
src/trunnel/socks5.trunnel | 2 +-
3 files changed, 50 insertions(+), 50 deletions(-)
diff --git a/src/trunnel/socks5.c b/src/trunnel/socks5.c
index 1d6f56dfa..5b8d49d80 100644
--- a/src/trunnel/socks5.c
+++ b/src/trunnel/socks5.c
@@ -2838,10 +2838,10 @@ socks5_server_method_parse(socks5_server_method_t **output, const uint8_t *input
}
return result;
}
-socks5_server_userpath_auth_t *
-socks5_server_userpath_auth_new(void)
+socks5_server_userpass_auth_t *
+socks5_server_userpass_auth_new(void)
{
- socks5_server_userpath_auth_t *val = trunnel_calloc(1, sizeof(socks5_server_userpath_auth_t));
+ socks5_server_userpass_auth_t *val = trunnel_calloc(1, sizeof(socks5_server_userpass_auth_t));
if (NULL == val)
return NULL;
val->version = 1;
@@ -2851,28 +2851,28 @@ socks5_server_userpath_auth_new(void)
/** Release all storage held inside 'obj', but do not free 'obj'.
*/
static void
-socks5_server_userpath_auth_clear(socks5_server_userpath_auth_t *obj)
+socks5_server_userpass_auth_clear(socks5_server_userpass_auth_t *obj)
{
(void) obj;
}
void
-socks5_server_userpath_auth_free(socks5_server_userpath_auth_t *obj)
+socks5_server_userpass_auth_free(socks5_server_userpass_auth_t *obj)
{
if (obj == NULL)
return;
- socks5_server_userpath_auth_clear(obj);
- trunnel_memwipe(obj, sizeof(socks5_server_userpath_auth_t));
+ socks5_server_userpass_auth_clear(obj);
+ trunnel_memwipe(obj, sizeof(socks5_server_userpass_auth_t));
trunnel_free_(obj);
}
uint8_t
-socks5_server_userpath_auth_get_version(const socks5_server_userpath_auth_t *inp)
+socks5_server_userpass_auth_get_version(const socks5_server_userpass_auth_t *inp)
{
return inp->version;
}
int
-socks5_server_userpath_auth_set_version(socks5_server_userpath_auth_t *inp, uint8_t val)
+socks5_server_userpass_auth_set_version(socks5_server_userpass_auth_t *inp, uint8_t val)
{
if (! ((val == 1))) {
TRUNNEL_SET_ERROR_CODE(inp);
@@ -2882,18 +2882,18 @@ socks5_server_userpath_auth_set_version(socks5_server_userpath_auth_t *inp, uint
return 0;
}
uint8_t
-socks5_server_userpath_auth_get_status(const socks5_server_userpath_auth_t *inp)
+socks5_server_userpass_auth_get_status(const socks5_server_userpass_auth_t *inp)
{
return inp->status;
}
int
-socks5_server_userpath_auth_set_status(socks5_server_userpath_auth_t *inp, uint8_t val)
+socks5_server_userpass_auth_set_status(socks5_server_userpass_auth_t *inp, uint8_t val)
{
inp->status = val;
return 0;
}
const char *
-socks5_server_userpath_auth_check(const socks5_server_userpath_auth_t *obj)
+socks5_server_userpass_auth_check(const socks5_server_userpass_auth_t *obj)
{
if (obj == NULL)
return "Object was NULL";
@@ -2905,11 +2905,11 @@ socks5_server_userpath_auth_check(const socks5_server_userpath_auth_t *obj)
}
ssize_t
-socks5_server_userpath_auth_encoded_len(const socks5_server_userpath_auth_t *obj)
+socks5_server_userpass_auth_encoded_len(const socks5_server_userpass_auth_t *obj)
{
ssize_t result = 0;
- if (NULL != socks5_server_userpath_auth_check(obj))
+ if (NULL != socks5_server_userpass_auth_check(obj))
return -1;
@@ -2921,24 +2921,24 @@ socks5_server_userpath_auth_encoded_len(const socks5_server_userpath_auth_t *obj
return result;
}
int
-socks5_server_userpath_auth_clear_errors(socks5_server_userpath_auth_t *obj)
+socks5_server_userpass_auth_clear_errors(socks5_server_userpass_auth_t *obj)
{
int r = obj->trunnel_error_code_;
obj->trunnel_error_code_ = 0;
return r;
}
ssize_t
-socks5_server_userpath_auth_encode(uint8_t *output, const size_t avail, const socks5_server_userpath_auth_t *obj)
+socks5_server_userpass_auth_encode(uint8_t *output, const size_t avail, const socks5_server_userpass_auth_t *obj)
{
ssize_t result = 0;
size_t written = 0;
uint8_t *ptr = output;
const char *msg;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
- const ssize_t encoded_len = socks5_server_userpath_auth_encoded_len(obj);
+ const ssize_t encoded_len = socks5_server_userpass_auth_encoded_len(obj);
#endif
- if (NULL != (msg = socks5_server_userpath_auth_check(obj)))
+ if (NULL != (msg = socks5_server_userpass_auth_check(obj)))
goto check_failed;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
@@ -2983,11 +2983,11 @@ socks5_server_userpath_auth_encode(uint8_t *output, const size_t avail, const so
return result;
}
-/** As socks5_server_userpath_auth_parse(), but do not allocate the
+/** As socks5_server_userpass_auth_parse(), but do not allocate the
* output object.
*/
static ssize_t
-socks5_server_userpath_auth_parse_into(socks5_server_userpath_auth_t *obj, const uint8_t *input, const size_t len_in)
+socks5_server_userpass_auth_parse_into(socks5_server_userpass_auth_t *obj, const uint8_t *input, const size_t len_in)
{
const uint8_t *ptr = input;
size_t remaining = len_in;
@@ -3016,15 +3016,15 @@ socks5_server_userpath_auth_parse_into(socks5_server_userpath_auth_t *obj, const
}
ssize_t
-socks5_server_userpath_auth_parse(socks5_server_userpath_auth_t **output, const uint8_t *input, const size_t len_in)
+socks5_server_userpass_auth_parse(socks5_server_userpass_auth_t **output, const uint8_t *input, const size_t len_in)
{
ssize_t result;
- *output = socks5_server_userpath_auth_new();
+ *output = socks5_server_userpass_auth_new();
if (NULL == *output)
return -1;
- result = socks5_server_userpath_auth_parse_into(*output, input, len_in);
+ result = socks5_server_userpass_auth_parse_into(*output, input, len_in);
if (result < 0) {
- socks5_server_userpath_auth_free(*output);
+ socks5_server_userpass_auth_free(*output);
*output = NULL;
}
return result;
diff --git a/src/trunnel/socks5.h b/src/trunnel/socks5.h
index 8bc5af109..d8f13c2ab 100644
--- a/src/trunnel/socks5.h
+++ b/src/trunnel/socks5.h
@@ -74,14 +74,14 @@ struct socks5_server_method_st {
};
#endif
typedef struct socks5_server_method_st socks5_server_method_t;
-#if !defined(TRUNNEL_OPAQUE) && !defined(TRUNNEL_OPAQUE_SOCKS5_SERVER_USERPATH_AUTH)
-struct socks5_server_userpath_auth_st {
+#if !defined(TRUNNEL_OPAQUE) && !defined(TRUNNEL_OPAQUE_SOCKS5_SERVER_USERPASS_AUTH)
+struct socks5_server_userpass_auth_st {
uint8_t version;
uint8_t status;
uint8_t trunnel_error_code_;
};
#endif
-typedef struct socks5_server_userpath_auth_st socks5_server_userpath_auth_t;
+typedef struct socks5_server_userpass_auth_st socks5_server_userpass_auth_t;
#if !defined(TRUNNEL_OPAQUE) && !defined(TRUNNEL_OPAQUE_TOR_SOCKSAUTH_KEYVAL)
struct tor_socksauth_keyval_st {
uint16_t keylen;
@@ -697,62 +697,62 @@ uint8_t socks5_server_method_get_method(const socks5_server_method_t *inp);
* code on 'inp' on failure.
*/
int socks5_server_method_set_method(socks5_server_method_t *inp, uint8_t val);
-/** Return a newly allocated socks5_server_userpath_auth with all
+/** Return a newly allocated socks5_server_userpass_auth with all
* elements set to zero.
*/
-socks5_server_userpath_auth_t *socks5_server_userpath_auth_new(void);
-/** Release all storage held by the socks5_server_userpath_auth in
+socks5_server_userpass_auth_t *socks5_server_userpass_auth_new(void);
+/** Release all storage held by the socks5_server_userpass_auth in
* 'victim'. (Do nothing if 'victim' is NULL.)
*/
-void socks5_server_userpath_auth_free(socks5_server_userpath_auth_t *victim);
-/** Try to parse a socks5_server_userpath_auth from the buffer in
+void socks5_server_userpass_auth_free(socks5_server_userpass_auth_t *victim);
+/** Try to parse a socks5_server_userpass_auth from the buffer in
* 'input', using up to 'len_in' bytes from the input buffer. On
* success, return the number of bytes consumed and set *output to the
- * newly allocated socks5_server_userpath_auth_t. On failure, return
+ * newly allocated socks5_server_userpass_auth_t. On failure, return
* -2 if the input appears truncated, and -1 if the input is otherwise
* invalid.
*/
-ssize_t socks5_server_userpath_auth_parse(socks5_server_userpath_auth_t **output, const uint8_t *input, const size_t len_in);
+ssize_t socks5_server_userpass_auth_parse(socks5_server_userpass_auth_t **output, const uint8_t *input, const size_t len_in);
/** Return the number of bytes we expect to need to encode the
- * socks5_server_userpath_auth in 'obj'. On failure, return a negative
+ * socks5_server_userpass_auth in 'obj'. On failure, return a negative
* value. Note that this value may be an overestimate, and can even be
* an underestimate for certain unencodeable objects.
*/
-ssize_t socks5_server_userpath_auth_encoded_len(const socks5_server_userpath_auth_t *obj);
-/** Try to encode the socks5_server_userpath_auth from 'input' into
+ssize_t socks5_server_userpass_auth_encoded_len(const socks5_server_userpass_auth_t *obj);
+/** Try to encode the socks5_server_userpass_auth from 'input' into
* the buffer at 'output', using up to 'avail' bytes of the output
* buffer. On success, return the number of bytes used. On failure,
* return -2 if the buffer was not long enough, and -1 if the input
* was invalid.
*/
-ssize_t socks5_server_userpath_auth_encode(uint8_t *output, size_t avail, const socks5_server_userpath_auth_t *input);
+ssize_t socks5_server_userpass_auth_encode(uint8_t *output, size_t avail, const socks5_server_userpass_auth_t *input);
/** Check whether the internal state of the
- * socks5_server_userpath_auth in 'obj' is consistent. Return NULL if
+ * socks5_server_userpass_auth in 'obj' is consistent. Return NULL if
* it is, and a short message if it is not.
*/
-const char *socks5_server_userpath_auth_check(const socks5_server_userpath_auth_t *obj);
+const char *socks5_server_userpass_auth_check(const socks5_server_userpass_auth_t *obj);
/** Clear any errors that were set on the object 'obj' by its setter
* functions. Return true iff errors were cleared.
*/
-int socks5_server_userpath_auth_clear_errors(socks5_server_userpath_auth_t *obj);
+int socks5_server_userpass_auth_clear_errors(socks5_server_userpass_auth_t *obj);
/** Return the value of the version field of the
- * socks5_server_userpath_auth_t in 'inp'
+ * socks5_server_userpass_auth_t in 'inp'
*/
-uint8_t socks5_server_userpath_auth_get_version(const socks5_server_userpath_auth_t *inp);
+uint8_t socks5_server_userpass_auth_get_version(const socks5_server_userpass_auth_t *inp);
/** Set the value of the version field of the
- * socks5_server_userpath_auth_t in 'inp' to 'val'. Return 0 on
+ * socks5_server_userpass_auth_t in 'inp' to 'val'. Return 0 on
* success; return -1 and set the error code on 'inp' on failure.
*/
-int socks5_server_userpath_auth_set_version(socks5_server_userpath_auth_t *inp, uint8_t val);
+int socks5_server_userpass_auth_set_version(socks5_server_userpass_auth_t *inp, uint8_t val);
/** Return the value of the status field of the
- * socks5_server_userpath_auth_t in 'inp'
+ * socks5_server_userpass_auth_t in 'inp'
*/
-uint8_t socks5_server_userpath_auth_get_status(const socks5_server_userpath_auth_t *inp);
+uint8_t socks5_server_userpass_auth_get_status(const socks5_server_userpass_auth_t *inp);
/** Set the value of the status field of the
- * socks5_server_userpath_auth_t in 'inp' to 'val'. Return 0 on
+ * socks5_server_userpass_auth_t in 'inp' to 'val'. Return 0 on
* success; return -1 and set the error code on 'inp' on failure.
*/
-int socks5_server_userpath_auth_set_status(socks5_server_userpath_auth_t *inp, uint8_t val);
+int socks5_server_userpass_auth_set_status(socks5_server_userpass_auth_t *inp, uint8_t val);
/** Return a newly allocated tor_socksauth_keyval with all elements
* set to zero.
*/
diff --git a/src/trunnel/socks5.trunnel b/src/trunnel/socks5.trunnel
index 4818d1408..b6b8a34f2 100644
--- a/src/trunnel/socks5.trunnel
+++ b/src/trunnel/socks5.trunnel
@@ -64,7 +64,7 @@ struct socks5_client_userpass_auth {
char passwd[passwd_len];
}
-struct socks5_server_userpath_auth {
+struct socks5_server_userpass_auth {
u8 version IN [1];
u8 status;
}
