/* Set the input file (file object, (max) bytes to read ) */
static void f_input(INT32 args) {
NBIO_INT_T len = -1;
switch(args) {
case 2:
if(ARG(2).type != T_INT) {
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->input", 2, "integer");
} else {
len = ARG(2).u.integer;
}
/* FALL THROUGH */
case 1:
if(ARG(1).type != T_OBJECT) {
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->input", 1, "object");
} else {
/* Allocate a new input object and add it to our linked list */
new_input(ARG(1), len, 0);
}
break;
case 0:
SIMPLE_TOO_FEW_ARGS_ERROR("_Caudium.nbio()->input", 1);
break;
}
pop_n_elems(args-1);
}
int main(int argc, char *argv[]) {
struct timeval tv;
gettimeofday(&tv, NULL);
srand(tv.tv_sec ^ tv.tv_usec + getpid() + (getppid() << 12));
Skein1024_Ctxt_t ctx;
uint8_t hash[128];
int best = 1024;
int current;
time_t time_ref = time(NULL);
int nhash = 0;
int input_length = 0;
char input[101];
while (1) {
// Only refresh the input with a new random value every so often
if (nhash % INC_BEFORE_NEW == 0) {
input_length = new_input(input);
} else {
inc_input(input, input_length);
}
Skein1024_Init(&ctx, 1024);
Skein1024_Update(&ctx, (uint8_t *) input, input_length);
Skein1024_Final(&ctx, hash);
++nhash;
// Rate reporting
// Overflow, stay accurate
if (nhash == 0)
time_ref = time(NULL);
else if (nhash % HASH_BEFORE_REPORT == 0) {
double khash = nhash / 1000.0;
fprintf(stderr, "%f khash/s\n", khash / (double)(time(NULL) - time_ref));
}
current = bitdiff(hash, oracle);
if (current < best) {
best = current;
printf("%d %s\n", best, input);
fflush(stdout);
}
}
return 0;
}
int main(int argc, char* argv[]){
qRegisterMetaType<input_event_t>();
QPubApp a(argc,argv);
MouseReader mouse;
QObject::connect(&mouse,SIGNAL(mouse_event(input_event_t)),&a,SLOT(new_input(input_event_t)));
mouse.start();
catchUnixSignals({SIGQUIT, SIGINT, SIGTERM, SIGHUP});
return a.exec();
}
/* Set the output data (string) */
static void f_write(INT32 args) {
if(args) {
if(ARG(1).type != T_STRING) {
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->write", 1, "string");
} else {
int len = ARG(1).u.string->len << ARG(1).u.string->size_shift;
if(len > 0)
new_input(ARG(1), len, 0);
}
} else {
SIMPLE_TOO_FEW_ARGS_ERROR("_Caudium.nbio()->write", 1);
}
pop_n_elems(args-1);
}
/*! @decl void write(string bytes)
*!
*! Add an input string to this pipe.
*/
static void pipe_write(INT32 args)
{
struct input *i;
if (args<1 || sp[-args].type!=T_STRING)
Pike_error("illegal argument to pipe->write()\n");
if (!THIS->firstinput)
{
append_buffer(sp[-args].u.string);
pop_n_elems(args);
push_int(0);
return;
}
i=new_input();
i->type=I_STRING;
nstrings++;
add_ref(i->u.str=sp[-args].u.string);
pop_n_elems(args-1);
}
void CL_Collada_Triangles_Impl::load_inputs(CL_DomElement &polylist_element, std::vector<CL_Collada_Source> &sources, CL_Collada_Vertices &vertices)
{
stride = 1;
CL_DomNode cur_child(polylist_element.get_first_child());
while (!cur_child.is_null())
{
if(cur_child.get_node_name() == "input")
{
CL_DomElement input_element = cur_child.to_element();
CL_Collada_Input_Shared new_input(input_element, sources, vertices);
// Find the stride
int offset = new_input.get_offset();
offset++; // Make comparible with stride (1 to x)
if (offset > stride)
stride = offset;
inputs.push_back( new_input );
}
cur_child = cur_child.get_next_sibling();
}
}
/*! @decl void input(object obj)
*!
*! Add an input file to this pipe.
*/
static void pipe_input(INT32 args)
{
struct input *i;
int fd=-1; /* Per, one less warning to worry about... */
struct object *obj;
if (args<1 || sp[-args].type != T_OBJECT)
Pike_error("Bad/missing argument 1 to pipe->input().\n");
obj=sp[-args].u.object;
if(!obj || !obj->prog)
Pike_error("pipe->input() on destructed object.\n");
push_int(0);
apply(sp[-args-1].u.object,"set_id", 1);
pop_stack();
i=new_input();
#if defined(HAVE_MMAP) && defined(HAVE_MUNMAP)
/* We do not handle mmaps if we have a buffer */
if(THIS->fd == -1)
{
char *m;
struct stat s;
apply(obj, "query_fd", 0);
if(sp[-1].type == T_INT) fd=sp[-1].u.integer;
pop_stack();
if (fd != -1 && fstat(fd,&s)==0)
{
off_t filep=fd_lseek(fd, 0L, SEEK_CUR); /* keep the file pointer */
size_t len = s.st_size - filep;
if(S_ISREG(s.st_mode) /* regular file */
&& ((m=(char *)mmap(0, len, PROT_READ,
MAP_FILE|MAP_SHARED,fd,filep))+1))
{
mmapped += len;
i->type=I_MMAP;
i->len = len;
i->u.mmap=m;
#if defined(HAVE_MADVISE) && defined(MADV_SEQUENTIAL)
/* Mark the pages as sequential read only access... */
madvise(m, len, MADV_SEQUENTIAL);
#endif
pop_n_elems(args);
push_int(0);
return;
}
}
}
#endif
i->u.obj=obj;
nobjects++;
i->type=I_OBJ;
add_ref(i->u.obj);
i->set_nonblocking_offset=find_identifier("set_nonblocking",i->u.obj->prog);
i->set_blocking_offset=find_identifier("set_blocking",i->u.obj->prog);
if (i->set_nonblocking_offset<0 ||
i->set_blocking_offset<0)
{
if (find_identifier("read", i->u.obj->prog) < 0) {
/* Not even a read function */
free_object(i->u.obj);
i->u.obj=NULL;
i->type=I_NONE;
nobjects--;
Pike_error("illegal file object%s%s\n",
((i->set_nonblocking_offset<0)?"; no set_nonblocking":""),
((i->set_blocking_offset<0)?"; no set_blocking":""));
} else {
/* Try blocking mode */
i->type = I_BLOCKING_OBJ;
if (i==THIS->firstinput) {
/*
* FIXME: What if read_som_data() returns 0?
*/
read_some_data();
}
return;
}
}
if (i==THIS->firstinput)
{
push_callback(offset_input_read_callback);
push_int(0);
push_callback(offset_input_close_callback);
apply_low(i->u.obj,i->set_nonblocking_offset,3);
pop_stack();
}
else
{
/* DOESN'T WORK!!! */
push_int(0);
push_int(0);
push_callback(offset_input_close_callback);
apply_low(i->u.obj,i->set_nonblocking_offset,3);
pop_stack();
}
pop_n_elems(args);
push_int(0);
}
/* This function reads some data from the current input (file object)
*/
static INLINE int read_data(void)
{
int buf_size = READ_BUFFER_SIZE;
NBIO_INT_T to_read = 0;
char *rd;
input *inp;
redo:
DERR(fprintf(stderr, "Reading from blocking input.\n"));
THIS->buf_pos = 0;
inp = THIS->inputs;
if(inp == NULL)
return -1; /* No more inputs */
if(inp->type != NBIO_BLOCK_OBJ)
return -2; /* invalid input for read_data */
if(inp->fd != -1) {
char * ptr;
DERR(fprintf(stderr, "Reading from real fd.\n"));
if(inp->len != -1)
to_read = MIN(buf_size, inp->len - inp->pos);
else
to_read = buf_size;
if(THIS->buf == NULL || THIS->buf_size < to_read) {
alloc_data_buf(to_read);
}
ptr = THIS->buf;
THREADS_ALLOW();
to_read = fd_read(inp->fd, ptr, to_read);
THREADS_DISALLOW();
DERR(fprintf(stderr, "read %ld from file\n", (long)to_read));
} else {
DERR(fprintf(stderr, "Reading from fake fd.\n"));
if(inp->len != -1 && inp->pos >= inp->len) {
/* We are done reading from this one */
DERR(fprintf(stderr, "Data done from fake fd.\n"));
free_input(inp);
goto redo; /* goto == ugly, but we want to read the next input
* if any
*/
}
to_read = READ_BUFFER_SIZE;
push_int(to_read);
push_int(1);
apply_low(inp->u.file, inp->read_off, 2);
if(Pike_sp[-1].type == T_STRING) {
if(Pike_sp[-1].u.string->len == 0) {
DERR(fprintf(stderr, "Read zero bytes from fake fd (EOF).\n"));
to_read = 0;
} else {
new_input(Pike_sp[-1], 0, 1);
to_read = THIS->inputs->len;
inp->pos += to_read;
DERR(fprintf(stderr, "read %ld bytes from fake file\n",
(long)to_read));
pop_stack();
return -3; /* Got a string buffer appended to the input list */
}
} else if(Pike_sp[-1].type == T_INT && Pike_sp[-1].u.integer == 0) {
to_read = 0;
} else {
Pike_error("Incorrect result from read, expected string.\n");
}
pop_stack();
}
switch(to_read) {
case 0: /* EOF */
DERR(fprintf(stderr, "read zero blocking bytes == EOF\n"));
free_input(inp);
break;
case -1:
if(errno != EAGAIN) {
/* Got an error. Free input and continue */
DERR(perror("Error while reading:"));
free_input(inp);
}
goto redo;
default:
inp->pos += to_read;
if(inp->pos == inp->len) {
DERR(fprintf(stderr, "Done reading (position == length).\n"));
free_input(inp);
}
THIS->buf_len = to_read;
break;
}
return to_read;
}
BOOL LLEasyMessageSender::addField(e_message_variable_type var_type, const char* var_name, std::string input, BOOL hex)
{
LLStringUtil::trim(input);
if(input.length() < 1 && var_type != MVT_VARIABLE)
return FALSE;
U8 valueU8;
U16 valueU16;
U32 valueU32;
U64 valueU64;
S8 valueS8;
S16 valueS16;
S32 valueS32;
// S64 valueS64;
F32 valueF32;
F64 valueF64;
LLVector3 valueVector3;
LLVector3d valueVector3d;
LLVector4 valueVector4;
LLQuaternion valueQuaternion;
LLUUID valueLLUUID;
BOOL valueBOOL;
std::string input_lower = input;
LLStringUtil::toLower(input_lower);
if(input_lower == "$agentid")
input = gAgent.getID().asString();
else if(input_lower == "$sessionid")
input = gAgent.getSessionID().asString();
else if(input_lower == "$uuid")
{
LLUUID id;
id.generate();
input = id.asString();
}
else if(input_lower == "$circuitcode")
{
std::stringstream temp_stream;
temp_stream << gMessageSystem->mOurCircuitCode;
input = temp_stream.str();
}
else if(input_lower == "$regionhandle")
{
std::stringstream temp_stream;
temp_stream << (gAgent.getRegion() ? gAgent.getRegion()->getHandle() : 0);
input = temp_stream.str();
}
else if(input_lower == "$position" || input_lower == "$pos")
{
std::stringstream temp_stream;
valueVector3 = gAgent.getPositionAgent();
temp_stream << "<" << valueVector3[0] << ", " << valueVector3[1] << ", " << valueVector3[2] << ">";
input = temp_stream.str();
}
//convert from a text representation of hex to binary
if(hex)
{
if(var_type != MVT_VARIABLE && var_type != MVT_FIXED)
return FALSE;
int len = input_lower.length();
const char* cstr = input_lower.c_str();
std::string new_input("");
BOOL nibble = FALSE;
char byte = 0;
for(int i = 0; i < len; i++)
{
char c = cstr[i];
if(c >= 0x30 && c <= 0x39)
c -= 0x30;
else if(c >= 0x61 && c <= 0x66)
c -= 0x57;
else if(c != 0x20)
return FALSE;
else
continue;
if(!nibble)
byte = c << 4;
else
new_input.push_back(byte | c);
nibble = !nibble;
}
if(nibble)
return FALSE;
input = new_input;
}
std::stringstream stream(input);
std::vector<std::string> tokens;
switch(var_type)
{
case MVT_U8:
if(input.substr(0, 1) == "-")
return FALSE;
if((stream >> valueU32).fail())
return FALSE;
valueU8 = (U8)valueU32;
gMessageSystem->addU8(var_name, valueU8);
return TRUE;
break;
case MVT_U16:
if(input.substr(0, 1) == "-")
return FALSE;
if((stream >> valueU16).fail())
return FALSE;
gMessageSystem->addU16(var_name, valueU16);
return TRUE;
break;
case MVT_U32:
if(input.substr(0, 1) == "-")
return FALSE;
if((stream >> valueU32).fail())
return FALSE;
gMessageSystem->addU32(var_name, valueU32);
return TRUE;
break;
case MVT_U64:
if(input.substr(0, 1) == "-")
return FALSE;
if((stream >> valueU64).fail())
return FALSE;
gMessageSystem->addU64(var_name, valueU64);
return TRUE;
break;
case MVT_S8:
if((stream >> valueS8).fail())
return FALSE;
gMessageSystem->addS8(var_name, valueS8);
return TRUE;
break;
case MVT_S16:
if((stream >> valueS16).fail())
return FALSE;
gMessageSystem->addS16(var_name, valueS16);
return TRUE;
break;
case MVT_S32:
if((stream >> valueS32).fail())
return FALSE;
gMessageSystem->addS32(var_name, valueS32);
return TRUE;
break;
/*
case MVT_S64:
if((stream >> valueS64).fail())
return FALSE;
gMessageSystem->addS64(var_name, valueS64);
return TRUE;
break;
*/
case MVT_F32:
if((stream >> valueF32).fail())
return FALSE;
gMessageSystem->addF32(var_name, valueF32);
return TRUE;
break;
case MVT_F64:
if((stream >> valueF64).fail())
return FALSE;
gMessageSystem->addF64(var_name, valueF64);
return TRUE;
break;
case MVT_LLVector3:
LLStringUtil::trim(input);
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
return FALSE;
tokens = split(input.substr(1, input.length() - 2), ",");
if(tokens.size() != 3)
return FALSE;
for(int i = 0; i < 3; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF32).fail())
return FALSE;
valueVector3.mV[i] = valueF32;
}
gMessageSystem->addVector3(var_name, valueVector3);
return TRUE;
break;
case MVT_LLVector3d:
LLStringUtil::trim(input);
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
return FALSE;
tokens = split(input.substr(1, input.length() - 2), ",");
if(tokens.size() != 3)
return FALSE;
for(int i = 0; i < 3; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF64).fail())
return FALSE;
valueVector3d.mdV[i] = valueF64;
}
gMessageSystem->addVector3d(var_name, valueVector3d);
return TRUE;
break;
case MVT_LLVector4:
LLStringUtil::trim(input);
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
return FALSE;
tokens = split(input.substr(1, input.length() - 2), ",");
if(tokens.size() != 4)
return FALSE;
for(int i = 0; i < 4; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF32).fail())
return FALSE;
valueVector4.mV[i] = valueF32;
}
gMessageSystem->addVector4(var_name, valueVector4);
return TRUE;
break;
case MVT_LLQuaternion:
LLStringUtil::trim(input);
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
return FALSE;
tokens = split(input.substr(1, input.length() - 2), ",");
if(tokens.size() == 3)
{
for(int i = 0; i < 3; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF32).fail())
return FALSE;
valueVector3.mV[i] = valueF32;
}
valueQuaternion.unpackFromVector3(valueVector3);
}
else if(tokens.size() == 4)
{
for(int i = 0; i < 4; i++)
{
stream.clear();
stream.str(tokens[i]);
if((stream >> valueF32).fail())
return FALSE;
valueQuaternion.mQ[i] = valueF32;
}
}
else
return FALSE;
