memcached_return memcached_dump(memcached_st *ptr, memcached_dump_func *callback, void *context, uint32_t number_of_callbacks)
{
/* No support for Binary protocol yet */
if (ptr->flags & MEM_BINARY_PROTOCOL)
return MEMCACHED_FAILURE;
return ascii_dump(ptr, callback, context, number_of_callbacks);
}
memcached_return_t memcached_dump(memcached_st *ptr, memcached_dump_fn *callback, void *context, uint32_t number_of_callbacks)
{
/* No support for Binary protocol yet */
if (ptr->flags.binary_protocol)
return MEMCACHED_FAILURE;
return ascii_dump(ptr, callback, context, number_of_callbacks);
}
void data_dump(unsigned char *data, int length, int dumpstyle)
{
switch (dumpstyle) {
case READABLE:
readable_dump(data, length);
break;
case HEX:
hex_dump(data, length);
break;
default:
ascii_dump(data, length);
}
}
/*
Function that makes a complete ascii frame and sends on uart.
*/
int modbusRS485_send( u_char address, u_char function, u_char* data, uint8_t nbytes)
{
/* initialize variables */
u_char *ptr=NULL, frameLRCByte=0;
u_char rowFrameBuffer[MAX_ASCIIFRAME_SIZE],asciiFrameBuffer[MAX_ASCIIFRAME_SIZE];
int status = MODBUS_SUCCESS;
unsigned int i,endByteStartAdd;
ptz_write(RS485_DEVICE_WRITE_MODE);
usleep(10000);
if((address == 0x00) || (function== 0x00))
{
printf("modbusRS485_init:Wrong input data \n");
status = EMODBUS_ADDR_FUNC;
}
else
{
rowFrameBuffer[ADDR_INDEX] = address; //address
rowFrameBuffer[FUNC_INDEX] = function; //command
if(data == NULL)
rowFrameBuffer[DATALEN_INDEX] = 0x00;
else {
rowFrameBuffer[DATALEN_INDEX] = nbytes;
str_copy(&rowFrameBuffer[DATA_INDEX],data, nbytes);
}
rowFrameBuffer[ nbytes + DATA_INDEX ] = compute_LRCByte(&rowFrameBuffer[ADDR_INDEX], nbytes+ DATA_INDEX );
/*all parameter set in rowdatabuffer */
asciiFrameBuffer[START_BYTE_OFFSET] = START_BYTE; // start byte - ":"
nbytes= nbytes + DATA_INDEX + LRC_BYTE_SIZE; // Adding add+func+LRCcode with data
bytes2ascii(rowFrameBuffer, &asciiFrameBuffer[1],nbytes); //
endByteStartAdd = ASCII_CODE_SIZE * (nbytes);
asciiFrameBuffer[++endByteStartAdd] = END_BYTE1;
asciiFrameBuffer[++endByteStartAdd] = END_BYTE2;
status = uart_write(rs485port,asciiFrameBuffer,++endByteStartAdd);
if(status != MODBUS_SUCCESS){
printf("modbusRS485_send: uart_write failed \n");
}
usleep(13000);
// ptz_write(RS485_DEVICE_READ_MODE);
}
#if MODBUS_DEBUG
ascii_dump(asciiFrameBuffer,endByteStartAdd );
#endif
return status;
}
memcached_return_t memcached_dump(memcached_st *ptr, memcached_dump_fn *callback, void *context, uint32_t number_of_callbacks)
{
memcached_return_t rc;
if ((rc= initialize_query(ptr)) != MEMCACHED_SUCCESS)
{
return rc;
}
/*
No support for Binary protocol yet
@todo Fix this so that we just flush, switch to ascii, and then go back to binary.
*/
if (ptr->flags.binary_protocol)
return MEMCACHED_FAILURE;
return ascii_dump(ptr, callback, context, number_of_callbacks);
}
void raw_ndump(int level, struct frame *frm, int num)
{
if (!frm->len)
return;
switch (parser.flags & DUMP_TYPE_MASK) {
case DUMP_ASCII:
ascii_dump(level, frm, num);
break;
case DUMP_HEX:
hex_dump(level, frm, num);
break;
case DUMP_EXT:
ext_dump(level, frm, num);
break;
}
}
void SAM(C64 *the_c64)
{
bool done = false;
char c;
TheCPU = the_c64->TheCPU;
TheCPU1541 = the_c64->TheCPU1541;
TheVIC = the_c64->TheVIC;
TheSID = the_c64->TheSID;
TheCIA1 = the_c64->TheCIA1;
TheCIA2 = the_c64->TheCIA2;
// Get CPU registers and current memory configuration
TheCPU->GetState(&R64);
TheCPU->ExtConfig = (~R64.ddr | R64.pr) & 7;
TheCPU1541->GetState(&R1541);
#ifdef __riscos__
Wimp_CommandWindow((int)"SAM");
#endif
#ifdef AMIGA
if (!(fin = fout = ferr = fopen("CON:0/0/640/480/SAM", "w+")))
return;
#else
fin = stdin;
fout = stdout;
ferr = stdout;
#endif
access_1541 = false;
address = R64.pc;
fprintf(ferr, "\n *** SAM - Simple Assembler and Monitor ***\n *** Press 'h' for help ***\n\n");
init_abort();
display_registers();
while (!done) {
if (access_1541)
fprintf(ferr, "1541> ");
else
fprintf(ferr, "C64> ");
fflush(ferr);
read_line();
while ((c = get_char()) == ' ') ;
switch (c) {
case 'a': // Assemble
get_token();
assemble();
break;
case 'b': // Binary dump
get_token();
binary_dump();
break;
case 'c': // Compare
get_token();
compare();
break;
case 'd': // Disassemble
get_token();
disassemble();
break;
case 'e': // Interrupt vectors
int_vectors();
break;
case 'f': // Fill
get_token();
fill();
break;
case 'h': // Help
help();
break;
case 'i': // ASCII dump
get_token();
ascii_dump();
break;
case 'k': // Memory configuration
get_token();
mem_config();
break;
case 'l': // Load data
get_token();
load_data();
break;
case 'm': // Memory dump
get_token();
memory_dump();
break;
case 'n': // Screen code dump
get_token();
screen_dump();
break;
case 'o': // Redirect output
get_token();
redir_output();
break;
case 'p': // Sprite dump
get_token();
sprite_dump();
break;
case 'r': // Registers
get_reg_token();
registers();
break;
case 's': // Save data
get_token();
save_data();
break;
case 't': // Transfer
get_token();
transfer();
break;
case 'v': // View machine state
view_state();
break;
case 'x': // Exit
done = true;
break;
case ':': // Change memory
get_token();
modify();
break;
case '1': // Switch to 1541 mode
access_1541 = true;
break;
case '6': // Switch to C64 mode
access_1541 = false;
break;
case '?': // Compute expression
get_token();
print_expr();
break;
case '\n': // Blank line
break;
default: // Unknown command
error("Unknown command");
break;
}
}
exit_abort();
#ifdef AMIGA
fclose(fin);
#endif
if (fout != ferr)
fclose(fout);
#ifdef __riscos__
Wimp_CommandWindow(-1);
#endif
// Set CPU registers
TheCPU->SetState(&R64);
TheCPU1541->SetState(&R1541);
}
void
dump(
struct iface *ifp,
int direction,
struct mbuf *bp
){
struct mbuf *tbp;
uint size;
time_t timer;
char *cp;
struct iftype *ift;
FILE *fp;
if(ifp == NULL || (ifp->trace & direction) == 0
|| (fp = ifp->trfp) == NULL)
return; /* Nothing to trace */
ift = ifp->iftype;
switch(direction){
case IF_TRACE_IN:
if((ifp->trace & IF_TRACE_NOBC)
&& ift != NULL
&& (ift->addrtest != NULL)
&& (*ift->addrtest)(ifp,bp) == 0)
return; /* broadcasts are suppressed */
timer = (time_t) secclock();
cp = ctime(&timer);
cp[24] = '\0';
fprintf(fp,"\n%s - %s recv:\n",cp,ifp->name);
break;
case IF_TRACE_OUT:
timer = (time_t) secclock();
cp = ctime(&timer);
cp[24] = '\0';
fprintf(fp,"\n%s - %s sent:\n",cp,ifp->name);
break;
}
if(bp == NULL || (size = len_p(bp)) == 0){
fprintf(fp,"empty packet!!\n");
return;
}
dup_p(&tbp,bp,0,size);
if(tbp == NULL){
fprintf(fp,nospace);
return;
}
if(ift != NULL && ift->trace != NULL)
(*ift->trace)(fp,&tbp,1);
if(ifp->trace & IF_TRACE_ASCII){
/* Dump only data portion of packet in ascii */
ascii_dump(fp,&tbp);
} else if(ifp->trace & IF_TRACE_HEX){
/* Dump entire packet in hex/ascii */
free_p(&tbp);
dup_p(&tbp,bp,0,len_p(bp));
if(tbp != NULL)
hex_dump(fp,&tbp);
else
fprintf(fp,nospace);
}
free_p(&tbp);
}
/** Implements the end_interval function of the plugin API */
int corsaro_dos_end_interval(corsaro_t *corsaro, corsaro_interval_t *int_end)
{
int this_interval = int_end->time-STATE(corsaro)->first_interval;
khiter_t i;
attack_vector_t *vector;
attack_vector_t **attack_arr = NULL;
int attack_arr_cnt = 0;
uint8_t gbuf[12];
uint8_t cntbuf[4];
if(this_interval < CORSARO_DOS_INTERVAL)
{
/* we haven't run for long enough to dump */
return 0;
}
else
{
/* we either have hit exactly the right amount of time,
or we have gone for too long, dump now and reset the counter */
STATE(corsaro)->first_interval = int_end->time;
/* fall through and continue to dump */
}
/* this is an interval we care about */
/* malloc an array big enough to hold the entire hash even though we wont
need it to be that big */
if((attack_arr =
malloc(sizeof(attack_vector_t *)*
kh_size(STATE(corsaro)->attack_hash))) == NULL)
{
corsaro_log(__func__, corsaro,
"could not malloc array for attack vectors");
return -1;
}
/* classify the flows and dump the attack ones */
for(i = kh_begin(STATE(corsaro)->attack_hash);
i != kh_end(STATE(corsaro)->attack_hash); ++i)
{
if(kh_exist(STATE(corsaro)->attack_hash, i))
{
vector = kh_key(STATE(corsaro)->attack_hash, i);
if(attack_vector_is_expired(vector, int_end->time) != 0)
{
kh_del(av, STATE(corsaro)->attack_hash, i);
attack_vector_free(vector);
vector = NULL;
}
else if(attack_vector_is_attack(corsaro, vector, int_end->time) != 0)
{
/* this is an attack */
/* add it to the attack array so we can know how many
before we dump it */
attack_arr[attack_arr_cnt] = vector;
attack_arr_cnt++;
}
else
{
attack_vector_reset(vector);
}
}
}
corsaro_io_write_interval_start(corsaro, STATE(corsaro)->outfile,
&corsaro->interval_start);
if(corsaro->global_file != NULL)
{
corsaro_io_write_plugin_start(corsaro, corsaro->global_file,
PLUGIN(corsaro));
}
if(CORSARO_FILE_MODE(STATE(corsaro)->outfile) == CORSARO_FILE_MODE_ASCII)
{
if(corsaro->global_file != NULL)
{
/* global stats */
/* dump the number of mismatched packets and vectors */
corsaro_file_printf(corsaro, corsaro->global_file,
"mismatch: %"PRIu32"\n"
"attack_vectors: %"PRIu32"\n"
"non-attack_vectors: %"PRIu32"\n",
STATE(corsaro)->number_mismatched_packets,
attack_arr_cnt,
kh_size(STATE(corsaro)->attack_hash)
-attack_arr_cnt);
}
/* dump the number of vectors */
corsaro_file_printf(corsaro, STATE(corsaro)->outfile, "%"PRIu32"\n",
attack_arr_cnt);
/* dump the vectors */
for(i = 0; i < attack_arr_cnt; i++)
{
if(ascii_dump(corsaro, attack_arr[i]) != 0)
{
corsaro_log(__func__, corsaro, "could not dump hash");
return -1;
}
/* reset the interval stats */
attack_vector_reset(attack_arr[i]);
}
}
else if(CORSARO_FILE_MODE(STATE(corsaro)->outfile) == CORSARO_FILE_MODE_BINARY)
{
if(corsaro->global_file != NULL)
{
/* global stats */
bytes_htonl(&gbuf[0], STATE(corsaro)->number_mismatched_packets);
bytes_htonl(&gbuf[4], attack_arr_cnt);
bytes_htonl(&gbuf[8],
kh_size(STATE(corsaro)->attack_hash)-attack_arr_cnt);
if(corsaro_file_write(corsaro, corsaro->global_file,
&gbuf[0], 12) != 12)
{
corsaro_log(__func__, corsaro,
"could not dump global stats to file");
return -1;
}
}
/* dump the number of vectors */
bytes_htonl(&cntbuf[0], attack_arr_cnt);
if(corsaro_file_write(corsaro, STATE(corsaro)->outfile,
&cntbuf[0], 4) != 4)
{
corsaro_log(__func__, corsaro,
"could not dump vector count to file");
return -1;
}
/* dump the vectors */
for(i = 0; i < attack_arr_cnt; i++)
{
if(binary_dump(corsaro, attack_arr[i]) != 0)
{
corsaro_log(__func__, corsaro, "could not dump hash");
return -1;
}
attack_vector_reset(attack_arr[i]);
}
}
else
{
corsaro_log(__func__, corsaro, "invalid mode");
return -1;
}
if(corsaro->global_file != NULL)
{
corsaro_io_write_plugin_end(corsaro, corsaro->global_file,
PLUGIN(corsaro));
}
corsaro_io_write_interval_end(corsaro, STATE(corsaro)->outfile, int_end);
STATE(corsaro)->number_mismatched_packets = 0;
free(attack_arr);
/* if we are rotating, now is when we should do it */
if(corsaro_is_rotate_interval(corsaro))
{
/* close the current file */
if(STATE(corsaro)->outfile != NULL)
{
corsaro_file_close(corsaro, STATE(corsaro)->outfile);
STATE(corsaro)->outfile = NULL;
}
}
return 0;
}
