adulau/ssldump
1
0
Fork 0
mirror of https://github.com/adulau/ssldump.git synced 2024-12-03 14:57:13 +00:00
Code Issues Projects Releases Packages Wiki Activity

Convert old-style function definitions

Browse source
This commit is contained in:
William Robinet 2023-08-14 10:57:16 +02:00
parent 4799524de1
commit 00a631a28d
No known key found for this signature in database
GPG key ID: 003FA3DF74C7A949
25 changed files with 440 additions and 878 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
base/network.c
View file

@ -68,9 +68,8 @@ struct network_handler_ {
proto_ctx *ctx;
};
int network_handler_create(mod,handlerp)
proto_mod *mod;
n_handler **handlerp;
int
network_handler_create (proto_mod *mod, n_handler **handlerp)
{
int r,_status;
n_handler *handler=0;
@ -91,9 +90,8 @@ int network_handler_create(mod,handlerp)
return(_status);
}
int network_handler_destroy(mod,handlerp)
proto_mod *mod;
n_handler **handlerp;
int
network_handler_destroy (proto_mod *mod, n_handler **handlerp)
{
n_handler *handler=0;
if(!handlerp || !*handlerp)
@ -107,12 +105,8 @@ int network_handler_destroy(mod,handlerp)
return(0);
}
int network_process_packet(handler,timestamp,data,length,af)
n_handler *handler;
struct timeval *timestamp;
UCHAR *data;
int length;
int af;
int
network_process_packet (n_handler *handler, struct timeval *timestamp, UCHAR *data, int length, int af)
{
int r;
int hlen;
@ -208,9 +202,8 @@ int network_process_packet(handler,timestamp,data,length,af)
return(0);
}
int packet_copy(in,out)
packet *in;
packet **out;
int
packet_copy (packet *in, packet **out)
{
int _status;
@ -240,8 +233,8 @@ int packet_copy(in,out)
return(_status);
}
int packet_destroy(p)
packet *p;
int
packet_destroy (packet *p)
{
if(!p)
return(0);
@ -251,10 +244,8 @@ int packet_destroy(p)
return(0);
}
int timestamp_diff(t1,t0,diff)
struct timeval *t1;
struct timeval *t0;
struct timeval *diff;
int
timestamp_diff (struct timeval *t1, struct timeval *t0, struct timeval *diff)
{
long d;
@ -280,9 +271,8 @@ int timestamp_diff(t1,t0,diff)
int lookuphostname(so_st,namep)
struct sockaddr_storage *so_st;
char **namep;
int
lookuphostname (struct sockaddr_storage *so_st, char **namep)
{
int r = 1;
*namep = calloc(1, NI_MAXHOST);
@ -304,9 +294,8 @@ int lookuphostname(so_st,namep)
return(0);
}
int addrtotext(so_st,namep)
struct sockaddr_storage *so_st;
char **namep;
int
addrtotext (struct sockaddr_storage *so_st, char **namep)
{
*namep = calloc(1, NI_MAXHOST);
void *addr = NULL;

12
base/proto_mod.c
View file

@ -47,12 +47,8 @@
#include "network.h"
int create_proto_handler(mod,ctx,handlerp,conn,first_packet)
proto_mod *mod;
proto_ctx *ctx;
proto_handler **handlerp;
tcp_conn *conn;
struct timeval *first_packet;
int
create_proto_handler (proto_mod *mod, proto_ctx *ctx, proto_handler **handlerp, tcp_conn *conn, struct timeval *first_packet)
{
int r,_status;
proto_handler *handler=0;
@ -74,8 +70,8 @@ int create_proto_handler(mod,ctx,handlerp,conn,first_packet)
return(_status);
}
int destroy_proto_handler(handlerp)
proto_handler **handlerp;
int
destroy_proto_handler (proto_handler **handlerp)
{
if(!handlerp || !*handlerp)
return(0);

23
base/tcpconn.c
View file

@ -63,8 +63,8 @@ extern int conn_ttl;
static int zero_conn PROTO_LIST((tcp_conn *conn));
static int zero_conn(conn)
tcp_conn *conn;
static int
zero_conn (tcp_conn *conn)
{
memset(conn,0,sizeof(tcp_conn));
return(0);
@ -131,8 +131,8 @@ int tcp_create_conn(tcp_conn **connp,struct sockaddr_storage *i_addr,
return(0);
}
int tcp_destroy_conn(conn)
tcp_conn *conn;
int
tcp_destroy_conn (tcp_conn *conn)
{
conn_struct *c=conn->backptr;
@ -161,7 +161,8 @@ int tcp_destroy_conn(conn)
return(0);
}
int clean_old_conn() {
int
clean_old_conn (void) {
conn_struct *conn;
tcp_conn *tcpconn;
struct timeval dt;
@ -184,7 +185,8 @@ int clean_old_conn() {
return i;
}
int destroy_all_conn() {
int
destroy_all_conn (void) {
int i = 0;
while(first_conn) {
i++;
@ -193,8 +195,8 @@ int destroy_all_conn() {
return i;
}
int free_tcp_segment_queue(seg)
segment *seg;
int
free_tcp_segment_queue (segment *seg)
{
segment *tmp;
@ -208,9 +210,8 @@ int free_tcp_segment_queue(seg)
return(0);
}
int copy_tcp_segment_queue(out,in)
segment **out;
segment *in;
int
copy_tcp_segment_queue (segment **out, segment *in)
{
int r,_status;
segment *base=0;

30
base/tcppack.c
View file

@ -71,10 +71,8 @@ static int new_connection PROTO_LIST((proto_mod *handler,proto_ctx *ctx,
static int print_tcp_packet PROTO_LIST((packet *p));
int STRIM PROTO_LIST((UINT4 _seq,segment *s));
int process_tcp_packet(handler,ctx,p)
proto_mod *handler;
proto_ctx *ctx;
packet *p;
int
process_tcp_packet (proto_mod *handler, proto_ctx *ctx, packet *p)
{
int r,_status;
int direction;
@ -165,11 +163,8 @@ int process_tcp_packet(handler,ctx,p)
return(_status);
}
static int new_connection(handler,ctx,p,connp)
proto_mod *handler;
proto_ctx *ctx;
packet *p;
tcp_conn **connp;
static int
new_connection (proto_mod *handler, proto_ctx *ctx, packet *p, tcp_conn **connp)
{
int r,_status;
tcp_conn *conn=0;
@ -227,12 +222,8 @@ static int new_connection(handler,ctx,p,connp)
}
*/
static int process_data_segment(conn,handler,p,stream,direction)
tcp_conn *conn;
proto_mod *handler;
packet *p;
stream_data *stream;
int direction;
static int
process_data_segment (tcp_conn *conn, proto_mod *handler, packet *p, stream_data *stream, int direction)
{
int r,_status;
tcp_seq seq,right_edge;
@ -393,8 +384,8 @@ static int process_data_segment(conn,handler,p,stream,direction)
return(_status);
}
static int print_tcp_packet(p)
packet *p;
static int
print_tcp_packet (packet *p)
{
char *src=0,*dst=0;
@ -441,9 +432,8 @@ static int print_tcp_packet(p)
return(0);
}
int STRIM(_seq,s)
UINT4 _seq;
segment *s;
int
STRIM (UINT4 _seq, segment *s)
{
int l;
int off;

6
common/lib/debug.c
View file

@ -62,10 +62,8 @@ int debug(int class,char *format,...)
return(0);
}
int xdump(name,data,len)
char *name;
UCHAR *data;
int len;
int
xdump (char *name, UCHAR *data, int len)
{
int i;

58
common/lib/r_assoc.c
View file

@ -83,8 +83,8 @@ UINT4 hash_compute PROTO_LIST((char *key,int len,int size));
static int copy_assoc_chain PROTO_LIST((r_assoc_el **newp,
r_assoc_el *old));
int r_assoc_create(assocp)
r_assoc **assocp;
int
r_assoc_create (r_assoc **assocp)
{
r_assoc *assoc=0;
int _status;
@ -108,8 +108,8 @@ int r_assoc_create(assocp)
return(_status);
}
int r_assoc_destroy(assocp)
r_assoc **assocp;
int
r_assoc_destroy (r_assoc **assocp)
{
r_assoc *assoc;
int i;
@ -127,8 +127,8 @@ int r_assoc_destroy(assocp)
return(0);
}
static int destroy_assoc_chain(chain)
r_assoc_el *chain;
static int
destroy_assoc_chain (r_assoc_el *chain)
{
r_assoc_el *nxt;
@ -147,9 +147,8 @@ static int destroy_assoc_chain(chain)
return(0);
}
static int copy_assoc_chain(newp,old)
r_assoc_el **newp;
r_assoc_el *old;
static int
copy_assoc_chain (r_assoc_el **newp, r_assoc_el *old)
{
r_assoc_el *new=0,*ptr,*tmp;
int r,_status;
@ -197,11 +196,8 @@ static int copy_assoc_chain(newp,old)
return(_status);
}
static int r_assoc_fetch_bucket(assoc,key,len,bucketp)
r_assoc *assoc;
char *key;
int len;
r_assoc_el **bucketp;
static int
r_assoc_fetch_bucket (r_assoc *assoc, char *key, int len, r_assoc_el **bucketp)
{
UINT4 hash_value;
r_assoc_el *bucket;
@ -218,11 +214,8 @@ static int r_assoc_fetch_bucket(assoc,key,len,bucketp)
return(R_NOT_FOUND);
}
int r_assoc_fetch(assoc,key,len,datap)
r_assoc *assoc;
char *key;
int len;
void **datap;
int
r_assoc_fetch (r_assoc *assoc, char *key, int len, void **datap)
{
r_assoc_el *bucket;
int r;
@ -292,9 +285,8 @@ int r_assoc_insert(assoc,key,len,data,copy,destroy,how)
return(_status);
}
int r_assoc_copy(newp,old)
r_assoc **newp;
r_assoc *old;
int
r_assoc_copy (r_assoc **newp, r_assoc *old)
{
int r,_status,i;
r_assoc *new;
@ -320,9 +312,8 @@ int r_assoc_copy(newp,old)
return(_status);
}
int r_assoc_init_iter(assoc,iter)
r_assoc *assoc;
r_assoc_iterator *iter;
int
r_assoc_init_iter (r_assoc *assoc, r_assoc_iterator *iter)
{
int i;
@ -344,11 +335,8 @@ int r_assoc_init_iter(assoc,iter)
return(0);
}
int r_assoc_iter(iter,key,keyl,val)
r_assoc_iterator *iter;
void **key;
int *keyl;
void **val;
int
r_assoc_iter (r_assoc_iterator *iter, void **key, int *keyl, void **val)
{
int i;
r_assoc_el *ret;
@ -386,8 +374,8 @@ int r_assoc_iter(iter,key,keyl,val)
}
/* Delete the last returned value*/
int r_assoc_iter_delete(iter)
r_assoc_iterator *iter;
int
r_assoc_iter_delete (r_assoc_iterator *iter)
{
/* First unhook it from the list*/
if(!iter->prev->prev){
@ -411,10 +399,8 @@ int r_assoc_iter_delete(iter)
/*This is a hack from AMS. Supposedly, it's pretty good for strings, even
though it doesn't take into account all the data*/
UINT4 hash_compute(key,len,bits)
char *key;
int len;
int bits;
UINT4
hash_compute (char *key, int len, int bits)
{
UINT4 h=0;

7
common/lib/r_assoc_test.c
View file

@ -48,7 +48,8 @@
#include <r_common.h>
#include <r_assoc.h>
int main()
int
main (void)
{
char test_vector[1024],*v;
int rnd,ct,r;
@ -94,8 +95,8 @@ int main()
exit(0);
}
int fetch_test(assoc)
r_assoc *assoc;
int
fetch_test (r_assoc *assoc)
{
int ct;
char vec[4],*v;

19
common/lib/r_bitfield.c
View file

@ -12,9 +12,8 @@
#include <r_common.h>
#include "r_bitfield.h"
int r_bitfield_create(setp,size)
r_bitfield **setp;
UINT4 size;
int
r_bitfield_create (r_bitfield **setp, UINT4 size)
{
r_bitfield *set=0;
int _status;
@ -40,8 +39,8 @@ int r_bitfield_create(setp,size)
return(_status);
}
int r_bitfield_destroy(setp)
r_bitfield **setp;
int
r_bitfield_destroy (r_bitfield **setp)
{
r_bitfield *set;
@ -57,9 +56,8 @@ int r_bitfield_destroy(setp)
return(0);
}
int r_bitfield_set(set,bit)
r_bitfield *set;
int bit;
int
r_bitfield_set (r_bitfield *set, int bit)
{
int word=(bit-set->base)/32;
int bbit=(bit-set->base)%32;
@ -90,9 +88,8 @@ int r_bitfield_set(set,bit)
return(_status);
}
int r_bitfield_isset(set,bit)
r_bitfield *set;
int bit;
int
r_bitfield_isset (r_bitfield *set, int bit)
{
int word=(bit-set->base)/32;
int bbit=(bit-set->base)%32;

35
common/lib/r_data.c
View file

@ -48,10 +48,8 @@
#include <r_common.h>
#include <r_data.h>
int r_data_create(dp,d,l)
Data **dp;
UCHAR *d;
int l;
int
r_data_create (Data **dp, UCHAR *d, int l)
{
Data *d_=0;
int _status;
@ -74,9 +72,8 @@ int r_data_create(dp,d,l)
return(_status);
}
int r_data_alloc(dp,l)
Data **dp;
int l;
int
r_data_alloc (Data **dp, int l)
{
Data *d_=0;
int _status;
@ -97,10 +94,8 @@ int r_data_alloc(dp,l)
return(_status);
}
int r_data_make(dp,d,l)
Data *dp;
UCHAR *d;
int l;
int
r_data_make (Data *dp, UCHAR *d, int l)
{
if(!(dp->data=(UCHAR *)malloc(l)))
ERETURN(R_NO_MEMORY);
@ -111,8 +106,8 @@ int r_data_make(dp,d,l)
return(0);
}
int r_data_destroy(dp)
Data **dp;
int
r_data_destroy (Data **dp)
{
if(!dp || !*dp)
return(0);
@ -126,9 +121,8 @@ int r_data_destroy(dp)
return(0);
}
int r_data_copy(dst,src)
Data *dst;
Data *src;
int
r_data_copy (Data *dst, Data *src)
{
if(!(dst->data=(UCHAR *)malloc(src->len)))
ERETURN(R_NO_MEMORY);
@ -136,8 +130,8 @@ int r_data_copy(dst,src)
return(0);
}
int r_data_zfree(d)
Data *d;
int
r_data_zfree (Data *d)
{
if(!d)
return(0);
@ -148,9 +142,8 @@ int r_data_zfree(d)
return(0);
}
int r_data_compare(d1,d2)
Data *d1;
Data *d2;
int
r_data_compare (Data *d1, Data *d2)
{
if(d1->len<d2->len)
return(-1);

23
common/lib/r_list.c
View file

@ -61,8 +61,8 @@ struct r_list_ {
struct r_list_el_ *last;
};
int r_list_create(listp)
r_list **listp;
int
r_list_create (r_list **listp)
{
r_list *list=0;
int _status;
@ -79,8 +79,8 @@ int r_list_create(listp)
return(_status);
}
int r_list_destroy(listp)
r_list **listp;
int
r_list_destroy (r_list **listp)
{
r_list *list;
r_list_el *el;
@ -107,9 +107,8 @@ int r_list_destroy(listp)
return(0);
}
int r_list_copy(outp,in)
r_list**outp;
r_list *in;
int
r_list_copy (r_list **outp, r_list *in)
{
r_list *out=0;
r_list_el *el,*el2,*last=0;
@ -204,9 +203,8 @@ int r_list_append(list,value,copy,destroy)
return(_status);
}
int r_list_init_iter(list,iter)
r_list *list;
r_list_iterator *iter;
int
r_list_init_iter (r_list *list, r_list_iterator *iter)
{
iter->list=list;
iter->ptr=list->first;
@ -214,9 +212,8 @@ int r_list_init_iter(list,iter)
return(0);
}
int r_list_iter(iter,val)
r_list_iterator *iter;
void **val;
int
r_list_iter (r_list_iterator *iter, void **val)
{
if(!iter->ptr)
return(R_EOD);

4
common/lib/r_replace.c
View file

@ -49,8 +49,8 @@
#ifndef HAVE_STRDUP
char *strdup(str)
char *str;
char *
strdup (char *str)
{
int len=strlen(str);
char *n;

19
common/lib/r_time.c
View file

@ -84,10 +84,8 @@ int gettimeofday(struct timeval *tv, struct timezone *tzp)
}
#endif
/*Note that t1 must be > t0 */
int r_timeval_diff(t1,t0,diff)
struct timeval *t1;
struct timeval *t0;
struct timeval *diff;
int
r_timeval_diff (struct timeval *t1, struct timeval *t0, struct timeval *diff)
{
long d;
@ -111,10 +109,8 @@ int r_timeval_diff(t1,t0,diff)
return(0);
}
int r_timeval_add(t1,t2,sum)
struct timeval *t1;
struct timeval *t2;
struct timeval *sum;
int
r_timeval_add (struct timeval *t1, struct timeval *t2, struct timeval *sum)
{
long tv_sec,tv_usec,d;
@ -135,8 +131,8 @@ int r_timeval_add(t1,t2,sum)
return(0);
}
UINT8 r_timeval2int(tv)
struct timeval *tv;
UINT8
r_timeval2int (struct timeval *tv)
{
UINT8 r=0;
@ -147,7 +143,8 @@ UINT8 r_timeval2int(tv)
return r;
}
UINT8 r_gettimeint()
UINT8
r_gettimeint (void)
{
struct timeval tv;

26
common/lib/threads/pthreads/pthread.c
View file

@ -23,8 +23,8 @@ typedef struct {
static void *r_thread_real_create PROTO_LIST((void *arg));
static void *r_thread_real_create(arg)
void *arg;
static void *
r_thread_real_create (void *arg)
{
helper *h;
@ -61,19 +61,22 @@ int r_thread_fork(func,arg,id)
return(_status);
}
int r_thread_yield()
int
r_thread_yield (void)
{
pthread_yield();
}
int r_thread_exit()
int
r_thread_exit (void)
{
thread_count--;
pthread_exit(0);
return(0);
}
int r_thread_wait_last()
int
r_thread_wait_last (void)
{
do {
pthread_yield();
@ -84,8 +87,8 @@ int r_thread_wait_last()
return(0);
}
int r_rwlock_create(lockp)
r_rwlock **lockp;
int
r_rwlock_create (r_rwlock **lockp)
{
pthread_rwlock_t *lock;
int r;
@ -100,8 +103,8 @@ int r_rwlock_create(lockp)
return(0);
}
int r_rwlock_destroy(lock)
r_rwlock **lock;
int
r_rwlock_destroy (r_rwlock **lock)
{
pthread_rwlock_t *plock;
@ -115,9 +118,8 @@ int r_rwlock_destroy(lock)
return(0);
}
int r_rwlock_lock(lock,action)
r_rwlock *lock;
int action;
int
r_rwlock_lock (r_rwlock *lock, int action)
{
pthread_rwlock_t *plock;
int r,_status;

16
null/null_analyze.c
View file

@ -77,8 +77,8 @@ static int create_null_analyzer(void *handle, proto_ctx *ctx, tcp_conn *conn,
return(0);
}
int destroy_null_analyzer(objp)
proto_obj **objp;
int
destroy_null_analyzer (proto_obj **objp)
{
null_analyzer *obj;
@ -94,10 +94,8 @@ int destroy_null_analyzer(objp)
return(0);
}
int data_null_analyzer(_obj,seg,direction)
proto_obj *_obj;
segment *seg;
int direction;
int
data_null_analyzer (proto_obj *_obj, segment *seg, int direction)
{
#ifdef DEBUG
null_analyzer *obj=(null_analyzer *)_obj;
@ -124,10 +122,8 @@ int data_null_analyzer(_obj,seg,direction)
return(0);
}
int fin_null_analyzer(_obj,p,direction)
proto_obj *_obj;
packet *p;
int direction;
int
fin_null_analyzer (proto_obj *_obj, packet *p, int direction)
{
#ifdef DEBUG
null_analyzer *obj=(null_analyzer *)_obj;

25
pcap/pcap_logger.c
View file

@ -29,8 +29,8 @@ int pcap_fd = -1;
static uint8_t content_pcap_src_ether[ETHER_ADDR_LEN] = {0x02, 0x00, 0x00, 0x11, 0x11, 0x11};
static uint8_t content_pcap_dst_ether[ETHER_ADDR_LEN] = {0x02, 0x00, 0x00, 0x22, 0x22, 0x22};
static int init_pcap_logger(data)
void *data;
static int
init_pcap_logger (void *data)
{
char *pcap_outfile = (char *) data;
pcap_fd = open(pcap_outfile, O_RDWR|O_CREAT, DFLT_FILEMODE);
@ -47,7 +47,8 @@ static int init_pcap_logger(data)
return 0;
}
static int deinit_pcap_logger()
static int
deinit_pcap_logger (void)
{
fdatasync(pcap_fd);
close(pcap_fd);
@ -85,8 +86,8 @@ static int create_pcap_logger(proto_obj **objp, struct sockaddr_storage *i_addr,
return(_status);
}
static int destroy_pcap_logger(objp)
proto_obj **objp;
static int
destroy_pcap_logger (proto_obj **objp)
{
logpkt_ctx_t *pcap_obj;
@ -101,11 +102,8 @@ static int destroy_pcap_logger(objp)
return(0);
}
static int data_pcap_logger(_obj,data,len,dir)
proto_obj *_obj;
unsigned char *data;
unsigned int len;
int dir;
static int
data_pcap_logger (proto_obj *_obj, unsigned char *data, unsigned int len, int dir)
{
logpkt_ctx_t *pcap_obj = (logpkt_ctx_t *)_obj;
int direction;
@ -119,11 +117,8 @@ static int data_pcap_logger(_obj,data,len,dir)
return status;
}
int close_pcap_logger(_obj,data,len,dir)
proto_obj *_obj;
unsigned char *data;
unsigned int len;
int dir;
int
close_pcap_logger (proto_obj *_obj, unsigned char *data, unsigned int len, int dir)
{
logpkt_ctx_t *pcap_obj = (logpkt_ctx_t *)_obj;
int direction;

18
ssl/Attic/lex.yy.c
View file

@ -1024,7 +1024,8 @@ ECHO;
* EOB_ACT_END_OF_FILE - end of file
*/
static int yy_get_next_buffer()
static int
yy_get_next_buffer (void)
{
register char *dest = yy_current_buffer->yy_ch_buf;
register char *source = yytext_ptr;
@ -1156,7 +1157,8 @@ static int yy_get_next_buffer()
/* yy_get_previous_state - get the state just before the EOB char was reached */
static yy_state_type yy_get_previous_state()
static yy_state_type
yy_get_previous_state (void)
{
register yy_state_type yy_current_state;
register char *yy_cp;
@ -1636,7 +1638,8 @@ int new_state;
#ifndef YY_NO_POP_STATE
static void yy_pop_state()
static void
yy_pop_state (void)
{
if ( --yy_start_stack_ptr < 0 )
YY_FATAL_ERROR( "start-condition stack underflow" );
@ -1647,7 +1650,8 @@ static void yy_pop_state()
#ifndef YY_NO_TOP_STATE
static int yy_top_state()
static int
yy_top_state (void)
{
return yy_start_stack[yy_start_stack_ptr - 1];
}
@ -1760,7 +1764,8 @@ void *ptr;
}
#if YY_MAIN
int main()
int
main (void)
{
yylex();
return 0;
@ -1768,7 +1773,8 @@ int main()
#endif
#line 60 "ssl.l"
int mkname()
int
mkname (void)
{
#if 0
printf("%s\n",yytext);

12
ssl/Attic/main.c
View file

@ -62,9 +62,8 @@ int verr_exit(char *fmt,...)
}
int main(argc,argv)
int argc;
char **argv;
int
main (int argc, char **argv)
{
char name[100];
FILE *in;
@ -86,12 +85,13 @@ int main(argc,argv)
extern int yylineno;
int yywrap()
int
yywrap (void)
{
;}
int yyerror(s)
char *s;
int
yyerror (char *s)
{
printf("Parse error %s at line %d\n",s,yylineno);
exit(1);

98
ssl/Attic/ssl_enum.c
View file

@ -1,27 +1,18 @@
#include "network.h"
#include "ssl.h"
#include "sslprint.h"
static int decode_ContentType_change_cipher_spec(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_ContentType_change_cipher_spec (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_ContentType_alert(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_ContentType_alert (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_ContentType_handshake(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_ContentType_handshake (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -41,11 +32,8 @@ static int decode_ContentType_handshake(ssl,dir,seg,data)
ssl_decode_switch(ssl,HandshakeType_decoder,t,dir,seg,data);
}
static int decode_ContentType_application_data(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_ContentType_application_data (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
@ -73,19 +61,13 @@ decoder ContentType_decoder[]={
{-1}
};
static int decode_HandshakeType_hello_request(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_hello_request (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_HandshakeType_client_hello(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_client_hello (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -128,11 +110,8 @@ static int decode_HandshakeType_client_hello(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_server_hello(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_server_hello (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -153,59 +132,38 @@ static int decode_HandshakeType_server_hello(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_certificate(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_certificate (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_HandshakeType_server_key_exchange(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_server_key_exchange (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_HandshakeType_certificate_request(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_certificate_request (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_HandshakeType_server_hello_done(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_server_hello_done (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_HandshakeType_certificate_verify(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_certificate_verify (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_HandshakeType_client_key_exchange(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_client_key_exchange (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_HandshakeType_finished(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_finished (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}

5
ssl/ciphersuites.c
View file

@ -233,9 +233,8 @@ static SSL_CipherSuite CipherSuites[]={
{-1}
};
int ssl_find_cipher(num,cs)
int num;
SSL_CipherSuite **cs;
int
ssl_find_cipher (int num, SSL_CipherSuite **cs)
{
SSL_CipherSuite *c;

399
ssl/ssl.enums.c
View file

@ -10,11 +10,8 @@
#include "ssl.enums.h"
static int decode_extension(ssl_obj *ssl, int dir, segment *seg, Data *data);
static int decode_server_name(ssl_obj *ssl, int dir, segment *seg, Data *data);
static int decode_ContentType_ChangeCipherSpec(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_ContentType_ChangeCipherSpec (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
struct json_object *jobj;
@ -35,11 +32,8 @@ static int decode_ContentType_ChangeCipherSpec(ssl,dir,seg,data)
return(0);
}
static int decode_ContentType_Alert(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_ContentType_Alert (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
@ -74,11 +68,8 @@ static int decode_ContentType_Alert(ssl,dir,seg,data)
return(0);
}
static int decode_ContentType_Handshake(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_ContentType_Handshake (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -122,11 +113,8 @@ static int decode_ContentType_Handshake(ssl,dir,seg,data)
return(0);
}
static int decode_ContentType_application_data(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_ContentType_application_data (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -172,11 +160,8 @@ decoder ContentType_decoder[]={
{-1}
};
static int decode_HandshakeType_HelloRequest(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_HelloRequest (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
struct json_object *jobj;
jobj = ssl->cur_json_st;
@ -187,11 +172,8 @@ static int decode_HandshakeType_HelloRequest(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_ClientHello(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_ClientHello (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
struct json_object *jobj;
jobj = ssl->cur_json_st;
@ -375,11 +357,8 @@ static int decode_HandshakeType_ClientHello(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_ServerHello(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_ServerHello (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
@ -520,11 +499,8 @@ static int decode_HandshakeType_ServerHello(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_Certificate(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_Certificate (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
UINT4 len,exlen,ex;
Data cert;
@ -569,11 +545,8 @@ static int decode_HandshakeType_Certificate(ssl,dir,seg,data)
}
static int decode_HandshakeType_SessionTicket(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_SessionTicket (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
UINT4 exlen, ex, val;
@ -601,11 +574,8 @@ static int decode_HandshakeType_SessionTicket(ssl,dir,seg,data)
}
}
static int decode_HandshakeType_EncryptedExtensions(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_EncryptedExtensions (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
UINT4 exlen, ex;
@ -626,11 +596,8 @@ static int decode_HandshakeType_EncryptedExtensions(ssl,dir,seg,data)
}
}
static int decode_HandshakeType_ServerKeyExchange(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_ServerKeyExchange (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -666,11 +633,8 @@ static int decode_HandshakeType_ServerKeyExchange(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_CertificateRequest(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_CertificateRequest (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -706,11 +670,8 @@ static int decode_HandshakeType_CertificateRequest(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_ServerHelloDone(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_ServerHelloDone (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
struct json_object *jobj;
@ -722,11 +683,8 @@ static int decode_HandshakeType_ServerHelloDone(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_CertificateVerify(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_CertificateVerify (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -746,11 +704,8 @@ static int decode_HandshakeType_CertificateVerify(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_ClientKeyExchange(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_ClientKeyExchange (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -789,11 +744,8 @@ static int decode_HandshakeType_ClientKeyExchange(ssl,dir,seg,data)
return(0);
}
static int decode_HandshakeType_Finished(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_Finished (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
@ -822,11 +774,8 @@ static int decode_HandshakeType_Finished(ssl,dir,seg,data)
}
static int decode_HandshakeType_KeyUpdate(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_HandshakeType_KeyUpdate (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
LF;
ssl_tls13_update_keying_material(ssl, ssl->decoder, dir);
@ -2463,22 +2412,16 @@ decoder cipher_suite_decoder[]={
{-1}
};
static int decode_AlertLevel_warning(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertLevel_warning (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "alert_level", json_object_new_string("warning"));
return(0);
}
static int decode_AlertLevel_fatal(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertLevel_fatal (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
struct json_object *jobj;
jobj = ssl->cur_json_st;
@ -2499,187 +2442,118 @@ decoder AlertLevel_decoder[]={
{-1}
};
static int decode_AlertDescription_close_notify(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_close_notify (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_unexpected_message(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_unexpected_message (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_bad_record_mac(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_bad_record_mac (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_decryption_failed(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_decryption_failed (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_record_overflow(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_record_overflow (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_decompression_failure(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_decompression_failure (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_handshake_failure(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_handshake_failure (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_bad_certificate(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_bad_certificate (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_unsupported_certificate(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_unsupported_certificate (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_certificate_revoked(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_certificate_revoked (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_certificate_expired(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_certificate_expired (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_certificate_unknown(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_certificate_unknown (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_illegal_parameter(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_illegal_parameter (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_unknown_ca(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_unknown_ca (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_access_denied(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_access_denied (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_decode_error(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_decode_error (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_decrypt_error(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_decrypt_error (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_export_restriction(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_export_restriction (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_protocol_version(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_protocol_version (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_insufficient_security(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_insufficient_security (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_internal_error(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_internal_error (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_user_canceled(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_user_canceled (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_AlertDescription_no_renegotiation(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_AlertDescription_no_renegotiation (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
@ -2810,35 +2684,23 @@ decoder compression_method_decoder[]={
{-1}
};
static int decode_client_certificate_type_rsa_sign(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_client_certificate_type_rsa_sign (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_client_certificate_type_dss_sign(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_client_certificate_type_dss_sign (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_client_certificate_type_rsa_fixed_dh(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_client_certificate_type_rsa_fixed_dh (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
static int decode_client_certificate_type_dss_fixed_dh(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_client_certificate_type_dss_fixed_dh (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
return(0);
}
@ -2866,11 +2728,8 @@ decoder client_certificate_type_decoder[]={
{-1}
};
static int decode_extension_server_name(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_extension_server_name (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
UINT4 t,l;
int r,p;
@ -2902,11 +2761,8 @@ static int decode_extension_server_name(ssl,dir,seg,data)
}
return(0);
}
static int decode_extension_encrypt_then_mac(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_extension_encrypt_then_mac (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r,*etm;
UINT4 l;
@ -2920,11 +2776,8 @@ static int decode_extension_encrypt_then_mac(ssl,dir,seg,data)
dir==DIR_I2R?*etm=1:++*etm;
return(0);
}
static int decode_extension_extended_master_secret(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_extension_extended_master_secret (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r,*ems;
UINT4 l;
@ -2938,11 +2791,8 @@ static int decode_extension_extended_master_secret(ssl,dir,seg,data)
dir==DIR_I2R?*ems=1:++*ems;
return(0);
}
static int decode_extension(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_extension (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
UINT4 l;
@ -2965,11 +2815,8 @@ decoder supported_groups_decoder[] = {
{0x0104,"ffdhe8192",0},
};
// Extension #10 supported_groups (renamed from "elliptic_curves")
static int decode_extension_supported_groups(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_extension_supported_groups (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r,p;
UINT4 l,g;
@ -3007,11 +2854,8 @@ decoder ec_point_formats_decoder[] = {
{2,"ansiX962_compressed_char2",0,}
};
// Extension #11 ec_point_formats
static int decode_extension_ec_point_formats(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_extension_ec_point_formats (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r,p;
UINT4 l,f;
@ -3044,11 +2888,8 @@ static int decode_extension_ec_point_formats(ssl,dir,seg,data)
return(0);
}
static int decode_extension_supported_versions(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_extension_supported_versions (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
UINT4 len, version;
@ -3070,11 +2911,8 @@ decoder tls13_certificate_types[] = {
{2,"raw public key",0},
{3,"1609 dot 2",0}
};
static int decode_extension_client_certificate_type(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_extension_client_certificate_type (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
UINT4 len, certificate_type;
@ -3090,11 +2928,8 @@ static int decode_extension_client_certificate_type(ssl,dir,seg,data)
if (dir == DIR_R2I) ssl->extensions->client_certificate_type = certificate_type; // Server sets the client_certificate_type
}
static int decode_extension_server_certificate_type(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_extension_server_certificate_type (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
UINT4 len, certificate_type;
@ -3394,11 +3229,8 @@ decoder extension_decoder[] = {
{-1}
};
static int decode_server_name_type_host_name(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_server_name_type_host_name (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
UINT4 l;
@ -3424,11 +3256,8 @@ static int decode_server_name_type_host_name(ssl,dir,seg,data)
data->data+=l;
return(0);
}
static int decode_server_name(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
static int
decode_server_name (ssl_obj *ssl, int dir, segment *seg, Data *data)
{
int r;
UINT4 l;

75
ssl/ssl_analyze.c
View file

@ -162,8 +162,8 @@ flag_struct flags[]={
{0}
};
int parse_ssl_flag(flag)
int flag;
int
parse_ssl_flag (int flag)
{
flag_struct *fl;
@ -181,8 +181,8 @@ int parse_ssl_flag(flag)
return(0);
}
static int parse_ssl_flags(str)
char *str;
static int
parse_ssl_flags (char *str)
{
char *x,*y;
flag_struct *fl;
@ -214,9 +214,8 @@ static int parse_ssl_flags(str)
return(0);
}
static int create_ssl_ctx(handle,ctxp)
void *handle;
proto_ctx **ctxp;
static int
create_ssl_ctx (void *handle, proto_ctx **ctxp)
{
ssl_decode_ctx *ctx=0;
int r,_status;
@ -230,9 +229,8 @@ static int create_ssl_ctx(handle,ctxp)
return(_status);
}
static int destroy_ssl_ctx(handle,ctxp)
void *handle;
proto_ctx **ctxp;
static int
destroy_ssl_ctx (void *handle, proto_ctx **ctxp)
{
ssl_decode_ctx *ctx=0;
ctx=(ssl_decode_ctx *) *ctxp;
@ -292,8 +290,8 @@ static int create_ssl_analyzer(void *handle, proto_ctx *ctx, tcp_conn *conn,
return(_status);
}
static int destroy_ssl_analyzer(objp)
proto_obj **objp;
static int
destroy_ssl_analyzer (proto_obj **objp)
{
ssl_obj *obj;
@ -321,8 +319,8 @@ static int destroy_ssl_analyzer(objp)
}
static int free_r_queue(q)
r_queue *q;
static int
free_r_queue (r_queue *q)
{
FREE(q->data);
if(q->q) free_tcp_segment_queue(q->q);
@ -330,8 +328,8 @@ static int free_r_queue(q)
return(0);
}
static int create_r_queue(qp)
r_queue **qp;
static int
create_r_queue (r_queue **qp)
{
r_queue *q=0;
int _status;
@ -355,13 +353,8 @@ static int create_r_queue(qp)
return(_status);
}
static int read_ssl_record(obj,q,seg,offset,lastp,offsetp)
ssl_obj *obj;
r_queue *q;
segment *seg;
int offset;
segment **lastp;
int *offsetp;
static int
read_ssl_record (ssl_obj *obj, r_queue *q, segment *seg, int offset, segment **lastp, int *offsetp)
{
segment *last=seg;
@ -422,12 +415,8 @@ static int read_ssl_record(obj,q,seg,offset,lastp,offsetp)
}
static int read_data(q,seg,offset,lastp,offsetp)
r_queue *q;
segment *seg;
int offset;
segment **lastp;
int *offsetp;
static int
read_data (r_queue *q, segment *seg, int offset, segment **lastp, int *offsetp)
{
int tocpy=0,r,_status;
#ifdef DEBUG
@ -477,10 +466,8 @@ static int read_data(q,seg,offset,lastp,offsetp)
return(_status);
}
static int data_ssl_analyzer(_obj,seg,direction)
proto_obj *_obj;
segment *seg;
int direction;
static int
data_ssl_analyzer (proto_obj *_obj, segment *seg, int direction)
{
int _status,r;
r_queue *q;
@ -555,12 +542,8 @@ static int data_ssl_analyzer(_obj,seg,direction)
return(_status);
}
static int print_ssl_header(obj,direction,q,data,len)
ssl_obj *obj;
int direction;
segment *q;
UCHAR *data;
int len;
static int
print_ssl_header (ssl_obj *obj, int direction, segment *q, UCHAR *data, int len)
{
int ct=0;
segment *s;
@ -583,12 +566,8 @@ static int print_ssl_header(obj,direction,q,data,len)
return(0);
}
static int print_ssl_record(obj,direction,q,data,len)
ssl_obj *obj;
int direction;
segment *q;
UCHAR *data;
int len;
static int
print_ssl_record (ssl_obj *obj, int direction, segment *q, UCHAR *data, int len)
{
int r;
@ -614,10 +593,8 @@ static int print_ssl_record(obj,direction,q,data,len)
return(0);
}
int close_ssl_analyzer(_obj,p,dir)
proto_obj *_obj;
packet *p;
int dir;
int
close_ssl_analyzer (proto_obj *_obj, packet *p, int dir)
{
ssl_obj *ssl=(ssl_obj *)_obj;
char *what;

65
ssl/ssl_rec.c
View file

@ -104,12 +104,8 @@ static int tls_check_mac PROTO_LIST((ssl_rec_decoder *d,int ct,
int ver,UCHAR *data,UINT4 datalen,UCHAR *iv,UINT4 ivlen,UCHAR *mac));
static int fmt_seq PROTO_LIST((UINT4 num,UCHAR *buf));
int ssl_create_rec_decoder(dp,ssl,mk,sk,iv)
ssl_rec_decoder **dp;
ssl_obj *ssl;
UCHAR *mk;
UCHAR *sk;
UCHAR *iv;
int
ssl_create_rec_decoder (ssl_rec_decoder **dp, ssl_obj *ssl, UCHAR *mk, UCHAR *sk, UCHAR *iv)
{
int r,_status;
ssl_rec_decoder *dec=0;
@ -168,8 +164,8 @@ int ssl_create_rec_decoder(dp,ssl,mk,sk,iv)
return(_status);
}
int ssl_destroy_rec_decoder(dp)
ssl_rec_decoder **dp;
int
ssl_destroy_rec_decoder (ssl_rec_decoder **dp)
{
ssl_rec_decoder *d;
@ -195,25 +191,16 @@ int ssl_destroy_rec_decoder(dp)
#define MSB(a) ((a>>8)&0xff)
#define LSB(a) (a&0xff)
int tls13_update_rec_key(d,newkey,newiv)
ssl_rec_decoder *d;
UCHAR *newkey;
UCHAR *newiv;
int
tls13_update_rec_key (ssl_rec_decoder *d, UCHAR *newkey, UCHAR *newiv)
{
d->write_key->data = newkey;
d->implicit_iv->data = newiv;
d->seq = 0;
}
int tls13_decode_rec_data(ssl,d,ct,version,in,inl,out,outl)
ssl_obj *ssl;
ssl_rec_decoder *d;
int ct;
int version;
UCHAR *in;
int inl;
UCHAR *out;
int *outl;
int
tls13_decode_rec_data (ssl_obj *ssl, ssl_rec_decoder *d, int ct, int version, UCHAR *in, int inl, UCHAR *out, int *outl)
{
int pad,i;
int r,encpadl,x,_status=0;
@ -284,15 +271,8 @@ abort:
return _status;
}
int ssl_decode_rec_data(ssl,d,ct,version,in,inl,out,outl)
ssl_obj *ssl;
ssl_rec_decoder *d;
int ct;
int version;
UCHAR *in;
int inl;
UCHAR *out;
int *outl;
int
ssl_decode_rec_data (ssl_obj *ssl, ssl_rec_decoder *d, int ct, int version, UCHAR *in, int inl, UCHAR *out, int *outl)
{
#ifdef OPENSSL
int pad;
@ -426,9 +406,8 @@ int ssl_decode_rec_data(ssl,d,ct,version,in,inl,out,outl)
/* This should go to 2^128, but we're never really going to see
more than 2^64, so we cheat*/
static int fmt_seq(num,buf)
UINT4 num;
UCHAR *buf;
static int
fmt_seq (UINT4 num, UCHAR *buf)
{
UINT4 netnum;
@ -439,15 +418,8 @@ static int fmt_seq(num,buf)
return(0);
}
static int tls_check_mac(d,ct,ver,data,datalen,iv,ivlen,mac)
ssl_rec_decoder *d;
int ct;
int ver;
UCHAR *data;
UINT4 datalen;
UCHAR *iv;
UINT4 ivlen;
UCHAR *mac;
static int
tls_check_mac (ssl_rec_decoder *d, int ct, int ver, UCHAR *data, UINT4 datalen, UCHAR *iv, UINT4 ivlen, UCHAR *mac)
{
HMAC_CTX *hm = HMAC_CTX_new();
if(!hm)
@ -489,13 +461,8 @@ static int tls_check_mac(d,ct,ver,data,datalen,iv,ivlen,mac)
return(0);
}
int ssl3_check_mac(d,ct,ver,data,datalen,mac)
ssl_rec_decoder *d;
int ct;
int ver;
UCHAR *data;
UINT4 datalen;
UCHAR *mac;
int
ssl3_check_mac (ssl_rec_decoder *d, int ct, int ver, UCHAR *data, UINT4 datalen, UCHAR *mac)
{
EVP_MD_CTX *mc = EVP_MD_CTX_new();
const EVP_MD *md;

157
ssl/ssldecode.c
View file

@ -139,11 +139,8 @@ static int password_cb(char *buf,int num,int rwflag,void *userdata)
return(strlen(ssl_password));
}
int ssl_decode_ctx_create(dp,keyfile,pass,keylogfile)
ssl_decode_ctx **dp;
char *keyfile;
char *pass;
char *keylogfile;
int
ssl_decode_ctx_create (ssl_decode_ctx **dp, char *keyfile, char *pass, char *keylogfile)
{
#ifdef OPENSSL
ssl_decode_ctx *d=0;
@ -197,8 +194,8 @@ int ssl_decode_ctx_create(dp,keyfile,pass,keylogfile)
#endif
}
int ssl_decode_ctx_destroy(dp)
ssl_decode_ctx **dp;
int
ssl_decode_ctx_destroy (ssl_decode_ctx **dp)
{
#ifdef OPENSSL
ssl_decode_ctx *d = *dp;
@ -217,9 +214,8 @@ int ssl_decode_ctx_destroy(dp)
return(0);
}
int ssl_decoder_create(dp,ctx)
ssl_decoder **dp;
ssl_decode_ctx *ctx;
int
ssl_decoder_create (ssl_decoder **dp, ssl_decode_ctx *ctx)
{
int _status;
@ -241,8 +237,8 @@ int ssl_decoder_create(dp,ctx)
#endif
}
int ssl_decoder_destroy(dp)
ssl_decoder **dp;
int
ssl_decoder_destroy (ssl_decoder **dp)
{
#ifdef OPENSSL
ssl_decoder *d;
@ -267,10 +263,8 @@ int ssl_decoder_destroy(dp)
return(0);
}
int ssl_set_client_random(d,msg,len)
ssl_decoder *d;
UCHAR *msg;
int len;
int
ssl_set_client_random (ssl_decoder *d, UCHAR *msg, int len)
{
#ifdef OPENSSL
int r;
@ -282,10 +276,8 @@ int ssl_set_client_random(d,msg,len)
return(0);
}
int ssl_set_server_random(d,msg,len)
ssl_decoder *d;
UCHAR *msg;
int len;
int
ssl_set_server_random (ssl_decoder *d, UCHAR *msg, int len)
{
#ifdef OPENSSL
int r;
@ -297,10 +289,8 @@ int ssl_set_server_random(d,msg,len)
return(0);
}
int ssl_set_client_session_id(d,msg,len)
ssl_decoder *d;
UCHAR *msg;
int len;
int
ssl_set_client_session_id (ssl_decoder *d, UCHAR *msg, int len)
{
#ifdef OPENSSL
int r;
@ -314,11 +304,8 @@ int ssl_set_client_session_id(d,msg,len)
return(0);
}
int ssl_process_server_session_id(ssl,d,msg,len)
ssl_obj *ssl;
ssl_decoder *d;
UCHAR *msg;
int len;
int
ssl_process_server_session_id (ssl_obj *ssl, ssl_decoder *d, UCHAR *msg, int len)
{
#ifdef OPENSSL
int r,_status;
@ -359,11 +346,8 @@ int ssl_process_server_session_id(ssl,d,msg,len)
#endif
}
int ssl_process_client_session_id(ssl,d,msg,len)
ssl_obj *ssl;
ssl_decoder *d;
UCHAR *msg;
int len;
int
ssl_process_client_session_id (ssl_obj *ssl, ssl_decoder *d, UCHAR *msg, int len)
{
#ifdef OPENSSL
int _status;
@ -410,10 +394,8 @@ int ssl_process_handshake_finished(ssl_obj* ssl,ssl_decoder *dec, Data *data){
}
}
int ssl_process_change_cipher_spec(ssl,d,direction)
ssl_obj *ssl;
ssl_decoder *d;
int direction;
int
ssl_process_change_cipher_spec (ssl_obj *ssl, ssl_decoder *d, int direction)
{
#ifdef OPENSSL
if (ssl->version!=TLSV13_VERSION){
@ -431,13 +413,8 @@ int ssl_process_change_cipher_spec(ssl,d,direction)
#endif
return(0);
}
int ssl_decode_record(ssl,dec,direction,ct,version,d)
ssl_obj *ssl;
ssl_decoder *dec;
int direction;
int ct;
int version;
Data *d;
int
ssl_decode_record (ssl_obj *ssl, ssl_decoder *dec, int direction, int ct, int version, Data *d)
{
ssl_rec_decoder *rd;
UCHAR *out;
@ -493,9 +470,8 @@ int ssl_decode_record(ssl,dec,direction,ct,version,d)
#endif
}
int ssl_update_handshake_messages(ssl,data)
ssl_obj *ssl;
Data *data;
int
ssl_update_handshake_messages (ssl_obj *ssl, Data *data)
{
#ifdef OPENSSL
Data *hms;
@ -523,12 +499,8 @@ int ssl_update_handshake_messages(ssl,data)
}
static int ssl_create_session_lookup_key(ssl,id,idlen,keyp,keyl)
ssl_obj *ssl;
UCHAR *id;
UINT4 idlen;
UCHAR **keyp;
UINT4 *keyl;
static int
ssl_create_session_lookup_key (ssl_obj *ssl, UCHAR *id, UINT4 idlen, UCHAR **keyp, UINT4 *keyl)
{
UCHAR *key=0;
UINT4 l;
@ -554,9 +526,8 @@ static int ssl_create_session_lookup_key(ssl,id,idlen,keyp,keyl)
/* Look up the session id in the session cache and generate
the appropriate keying material */
int ssl_restore_session(ssl,d)
ssl_obj *ssl;
ssl_decoder *d;
int
ssl_restore_session (ssl_obj *ssl, ssl_decoder *d)
{
UCHAR *lookup_key=0;
void *msv;
@ -599,9 +570,8 @@ int ssl_restore_session(ssl,d)
/* Look up the session id in the session cache and generate
the appropriate keying material */
int ssl_save_session(ssl,d)
ssl_obj *ssl;
ssl_decoder *d;
int
ssl_save_session (ssl_obj *ssl, ssl_decoder *d)
{
#ifdef OPENSSL
UCHAR *lookup_key=0;
@ -634,11 +604,8 @@ int ssl_save_session(ssl,d)
/* This only works with RSA because the other cipher suites
offer PFS. Yuck. */
int ssl_process_client_key_exchange(ssl,d,msg,len)
ssl_obj *ssl;
ssl_decoder *d;
UCHAR *msg;
int len;
int
ssl_process_client_key_exchange (ssl_obj *ssl, ssl_decoder *d, UCHAR *msg, int len)
{
#ifdef OPENSSL
int r,_status;
@ -755,13 +722,8 @@ static int tls_P_hash(ssl,secret,seed,md,out)
}
static int tls_prf(ssl,secret,usage,rnd1,rnd2,out)
ssl_obj *ssl;
Data *secret;
char *usage;
Data *rnd1;
Data *rnd2;
Data *out;
static int
tls_prf (ssl_obj *ssl, Data *secret, char *usage, Data *rnd1, Data *rnd2, Data *out)
{
int r,_status;
Data *md5_out=0,*sha_out=0;
@ -813,13 +775,8 @@ static int tls_prf(ssl,secret,usage,rnd1,rnd2,out)
}
static int tls12_prf(ssl,secret,usage,rnd1,rnd2,out)
ssl_obj *ssl;
Data *secret;
char *usage;
Data *rnd1;
Data *rnd2;
Data *out;
static int
tls12_prf (ssl_obj *ssl, Data *secret, char *usage, Data *rnd1, Data *rnd2, Data *out)
{
const EVP_MD *md;
@ -861,11 +818,8 @@ static int tls12_prf(ssl,secret,usage,rnd1,rnd2,out)
}
static int ssl3_generate_export_iv(ssl,r1,r2,out)
ssl_obj *ssl;
Data *r1;
Data *r2;
Data *out;
static int
ssl3_generate_export_iv (ssl_obj *ssl, Data *r1, Data *r2, Data *out)
{
MD5_CTX md5;
UCHAR tmp[16];
@ -880,13 +834,8 @@ static int ssl3_generate_export_iv(ssl,r1,r2,out)
return(0);
}
static int ssl3_prf(ssl,secret,usage,r1,r2,out)
ssl_obj *ssl;
Data *secret;
char *usage;
Data *r1;
Data *r2;
Data *out;
static int
ssl3_prf (ssl_obj *ssl, Data *secret, char *usage, Data *r1, Data *r2, Data *out)
{
MD5_CTX md5;
SHA_CTX sha;
@ -951,9 +900,8 @@ static int ssl3_prf(ssl,secret,usage,r1,r2,out)
return(0);
}
static int ssl_generate_keying_material(ssl,d)
ssl_obj *ssl;
ssl_decoder *d;
static int
ssl_generate_keying_material (ssl_obj *ssl, ssl_decoder *d)
{
Data *key_block=0,temp;
UCHAR _iv_c[8],_iv_s[8];
@ -1189,10 +1137,8 @@ abort:
}
// Will update the keys for the particular direction
int ssl_tls13_update_keying_material(ssl,d,direction)
ssl_obj *ssl;
ssl_decoder *d;
int direction;
int
ssl_tls13_update_keying_material (ssl_obj *ssl, ssl_decoder *d, int direction)
{
Data *secret;
ssl_rec_decoder *decoder;
@ -1216,9 +1162,8 @@ int ssl_tls13_update_keying_material(ssl,d,direction)
return 0;
}
int ssl_tls13_generate_keying_material(ssl,d)
ssl_obj* ssl;
ssl_decoder *d;
int
ssl_tls13_generate_keying_material (ssl_obj *ssl, ssl_decoder *d)
{
int r,_status;
Data out;
@ -1287,9 +1232,8 @@ abort:
return r;
}
static int ssl_generate_session_hash(ssl,d)
ssl_obj *ssl;
ssl_decoder *d;
static int
ssl_generate_session_hash (ssl_obj *ssl, ssl_decoder *d)
{
int r,_status,dgi;
unsigned int len;
@ -1345,9 +1289,8 @@ static int read_hex_string(char *str, UCHAR *buf, int n) {
}
return 0;
}
static int ssl_read_key_log_file(ssl,d)
ssl_obj *ssl;
ssl_decoder *d;
static int
ssl_read_key_log_file (ssl_obj *ssl, ssl_decoder *d)
{
int r,_status,n,i;
unsigned int t;

121
ssl/sslprint.c
View file

@ -59,10 +59,8 @@ extern decoder HandshakeType_decoder[];
#define BYTES_NEEDED(x) (x<=255)?1:((x<=(1<<16))?2:(x<=(1<<24)?3:4))
int process_beginning_plaintext(ssl,seg,direction)
ssl_obj *ssl;
segment *seg;
int direction;
int
process_beginning_plaintext (ssl_obj *ssl, segment *seg, int direction)
{
Data d;
if(seg->len==0)
@ -89,9 +87,8 @@ int process_beginning_plaintext(ssl,seg,direction)
return(0);
}
int process_v2_hello(ssl,seg)
ssl_obj *ssl;
segment *seg;
int
process_v2_hello (ssl_obj *ssl, segment *seg)
{
int r;
int rec_len;
@ -213,13 +210,8 @@ int process_v2_hello(ssl,seg)
return(_status);
}
int ssl_decode_switch(ssl,dtable,value,dir,seg,data)
ssl_obj *ssl;
decoder *dtable;
int value;
int dir;
segment *seg;
Data *data;
int
ssl_decode_switch (ssl_obj *ssl, decoder *dtable, int value, int dir, segment *seg, Data *data)
{
while(dtable && dtable->type!=-1 && dtable->name!=NULL){
if(dtable->type == value){
@ -239,12 +231,8 @@ int ssl_decode_switch(ssl,dtable,value,dir,seg,data)
ERETURN(R_NOT_FOUND);
}
int ssl_expand_record(ssl,q,direction,data,len)
ssl_obj *ssl;
segment *q;
int direction;
UCHAR *data;
int len;
int
ssl_expand_record (ssl_obj *ssl, segment *q, int direction, UCHAR *data, int len)
{
int r;
Data d;
@ -319,13 +307,8 @@ int ssl_expand_record(ssl,q,direction,data,len)
return(0);
}
int ssl_decode_uintX(ssl,name,size,p,data,x)
ssl_obj *ssl;
char *name;
int size;
UINT4 p;
Data *data;
UINT4 *x;
int
ssl_decode_uintX (ssl_obj *ssl, char *name, int size, UINT4 p, Data *data, UINT4 *x)
{
UINT4 v=0;
UINT4 _x;
@ -351,13 +334,8 @@ int ssl_decode_uintX(ssl,name,size,p,data,x)
return(0);
}
int ssl_decode_opaque_array(ssl,name,size,p,data,x)
ssl_obj *ssl;
char *name;
int size;
UINT4 p;
Data *data;
Data *x;
int
ssl_decode_opaque_array (ssl_obj *ssl, char *name, int size, UINT4 p, Data *data, Data *x)
{
UINT4 len;
char n[1000];
@ -394,11 +372,8 @@ int ssl_decode_opaque_array(ssl,name,size,p,data,x)
return(0);
}
int ssl_lookup_enum(ssl,dtable,val,ptr)
ssl_obj *ssl;
decoder *dtable;
UINT4 val;
char **ptr;
int
ssl_lookup_enum (ssl_obj *ssl, decoder *dtable, UINT4 val, char **ptr)
{
while(dtable && dtable->type!=-1){
if(dtable->type == val){
@ -411,14 +386,8 @@ int ssl_lookup_enum(ssl,dtable,val,ptr)
return(R_NOT_FOUND);
}
int ssl_decode_enum(ssl,name,size,dtable,p,data,x)
ssl_obj *ssl;
char *name;
int size;
decoder *dtable;
UINT4 p;
Data *data;
UINT4 *x;
int
ssl_decode_enum (ssl_obj *ssl, char *name, int size, decoder *dtable, UINT4 p, Data *data, UINT4 *x)
{
int r;
UINT4 _x;
@ -437,11 +406,8 @@ int ssl_decode_enum(ssl,name,size,dtable,p,data,x)
return(0);
}
int ssl_print_enum(ssl,name,dtable,value)
ssl_obj *ssl;
char *name;
decoder *dtable;
UINT4 value;
int
ssl_print_enum (ssl_obj *ssl, char *name, decoder *dtable, UINT4 value)
{
if(name) explain(ssl,"%s ",name);
@ -460,11 +426,8 @@ int ssl_print_enum(ssl,name,dtable,value)
return(R_NOT_FOUND);
}
int ssl_get_enum_str(ssl,outstr,dtable,value)
ssl_obj *ssl;
char *outstr;
decoder *dtable;
UINT4 value;
int
ssl_get_enum_str (ssl_obj *ssl, char *outstr, decoder *dtable, UINT4 value)
{
while(dtable && dtable->type!=-1){
if(dtable->type == value){
@ -496,10 +459,8 @@ int explain(ssl_obj *ssl,char *format,...)
return(0);
}
int exdump(ssl,name,data)
ssl_obj *ssl;
char *name;
Data *data;
int
exdump (ssl_obj *ssl, char *name, Data *data)
{
int i;
if(!(SSL_print_flags & SSL_PRINT_JSON)) {
@ -528,10 +489,8 @@ int exdump(ssl,name,data)
return(0);
}
int exstr(ssl,outstr,data)
ssl_obj *ssl;
char *outstr;
Data *data;
int
exstr (ssl_obj *ssl, char *outstr, Data *data)
{
int i;
@ -548,10 +507,8 @@ int exstr(ssl,outstr,data)
return(0);
}
int combodump(ssl,name,data)
ssl_obj *ssl;
char *name;
Data *data;
int
combodump (ssl_obj *ssl, char *name, Data *data)
{
UCHAR *ptr=data->data;
int len=data->len;
@ -605,9 +562,8 @@ int combodump(ssl,name,data)
return(0);
}
int print_data(ssl,d)
ssl_obj *ssl;
Data *d;
int
print_data (ssl_obj *ssl, Data *d)
{
int i,bit8=0;
@ -661,9 +617,8 @@ int print_data(ssl,d)
return(0);
}
int ssl_print_direction_indicator(ssl,dir)
ssl_obj *ssl;
int dir;
int
ssl_print_direction_indicator (ssl_obj *ssl, int dir)
{
struct json_object *jobj;
#if 0
@ -706,9 +661,8 @@ int ssl_print_direction_indicator(ssl,dir)
return(0);
}
int ssl_print_timestamp(ssl,ts)
ssl_obj *ssl;
struct timeval *ts;
int
ssl_print_timestamp (ssl_obj *ssl, struct timeval *ts)
{
struct timeval dt;
int r;
@ -745,8 +699,8 @@ int ssl_print_timestamp(ssl,ts)
}
int ssl_print_record_num(ssl)
ssl_obj *ssl;
int
ssl_print_record_num (ssl_obj *ssl)
{
struct json_object *jobj;
jobj = ssl->cur_json_st;
@ -769,11 +723,8 @@ int ssl_print_record_num(ssl)
return(0);
}
int ssl_print_cipher_suite(ssl,version,p,val)
ssl_obj *ssl;
int version;
int p;
UINT4 val;
int
ssl_print_cipher_suite (ssl_obj *ssl, int version, int p, UINT4 val)
{
char *str;
char *prefix=version<=0x300?"SSL_":"TLS_";

22
ssl/sslxprint.c
View file

@ -62,10 +62,8 @@ static int sslx__print_dn PROTO_LIST((ssl_obj *ssl,char *x));
static int sslx__print_serial PROTO_LIST((ssl_obj *ssl,ASN1_INTEGER *a));
#endif
int sslx_print_certificate(ssl,data,pf)
ssl_obj *ssl;
Data *data;
int pf;
int
sslx_print_certificate (ssl_obj *ssl, Data *data, int pf)
{
#ifdef OPENSSL
X509 *x=0;
@ -188,10 +186,8 @@ int sslx_print_certificate(ssl,data,pf)
return(_status);
}
int sslx_print_dn(ssl,data,pf)
ssl_obj *ssl;
Data *data;
int pf;
int
sslx_print_dn (ssl_obj *ssl, Data *data, int pf)
{
UCHAR buf[BUFSIZE];
int _status;
@ -224,9 +220,8 @@ int sslx_print_dn(ssl,data,pf)
return(_status);
}
static int sslx__print_dn(ssl,x)
ssl_obj *ssl;
char *x;
static int
sslx__print_dn (ssl_obj *ssl, char *x)
{
char *slash;
@ -246,9 +241,8 @@ static int sslx__print_dn(ssl,x)
}
#ifdef OPENSSL
static int sslx__print_serial(ssl,a)
ssl_obj *ssl;
ASN1_INTEGER *a;
static int
sslx__print_serial (ssl_obj *ssl, ASN1_INTEGER *a)
{
Data d;