void
alder_wordtable_bigbitarray_print(alder_wordtable_bigbitarray_t *o)
{
bool isExit = false;
bstring bs = bfromcstralloc((int)o->maxsize * 10, " ");
alder_dwordtable_t x1 = 1;
for (size_t i = 0; i < o->blockarraysize; i++) {
for (size_t j = 0; j < o->subarraybits; j++) {
size_t pos = j + i * o->subarraybits;
if (j + i * o->subarraybits == o->maxsize) {
isExit = true;
break;
}
size_t k = j / o->blocksize;
size_t kbit = j % o->blocksize;
alder_dwordtable_t x = o->blockarray[i][k];
bformata(bs, "[%zu] ", pos);
if (x & (x1 << kbit)) {
bconchar(bs, '1');
} else {
bconchar(bs, '0');
}
bconchar(bs, ' ');
}
if (isExit == true) {
break;
}
}
alder_log5("bit: %s", bdata(bs));
bdestroy(bs);
}
void str2BitMask(const char* str, BitMask* mask)
{
char* endptr;
errno = 0;
struct bstrList* tokens;
bstring q = bfromcstralloc (60, str);
tokens = bsplit(q,' ');
for (int i=0; i<tokens->qty; i++)
{
uint64_t val = strtoull((char*) tokens->entry[i]->data, &endptr, 16);
if ((errno == ERANGE && val == LONG_MAX )
|| (errno != 0 && val == 0))
{
ERROR;
}
if (endptr == str)
{
ERROR_PLAIN_PRINT(No digits were found);
}
mask->mask[i] = val;
}
bstrListDestroy(tokens);
bdestroy(q);
}
bool ebml_write_header(struct ebml_writer *writer, const_bstring format_name)
{
if (!ebml_start_tag(writer, EBML_HEADER_TAG))
return false;
bstring name_buf = bfromcstralloc(128, "");
if (!name_buf)
return false;
bool ok = true;
if (binsertch(name_buf, 0, 32, '\0') != BSTR_OK) {
fprintf(stderr, "bpattern()\n");
ok = false;
goto out;
}
if (bsetstr(name_buf, 0, format_name, '\0') != BSTR_OK) {
fprintf(stderr, "bsetstr()\n");
ok = false;
goto out;
}
if (!fwrite(name_buf->data, name_buf->slen + 1, 1, writer->f)) {
perror("fwrite");
ok = false;
goto out;
}
ebml_end_tag(writer);
out:
bdestroy(name_buf);
return ok;
}
static bstring
ssh_arg_to_privkey(const bstring argkey)
{
struct tagbstring tmp;
bstring privkey;
int i, len;
/*
* A simple routine to convert from the private key format suitable for
* inclusion in a Torrc back to PEM.
*/
len = strlen(OBFSPROXYSSH_PEM_HDR) + blength(argkey) +
blength(argkey) /64 + 1 + strlen(OBFSPROXYSSH_PEM_FTR);
privkey = bfromcstralloc(len, OBFSPROXYSSH_PEM_HDR);
for (i = 0; i < blength(argkey); i += 64) {
bmid2tbstr(tmp, argkey, i, 64);
bconcat(privkey, &tmp);
bconchar(privkey, '\n');
}
bcatcstr(privkey, OBFSPROXYSSH_PEM_FTR);
return privkey;
}
struct dbg_sym_payload_label* dbgfmt_get_symbol_label(struct dbg_sym* bytes)
{
struct dbg_sym_payload_label* result = malloc(sizeof(struct dbg_sym_payload_label));
size_t str_length = bytes->length - 2 * sizeof(uint16_t);
result->label = bfromcstralloc(str_length + 1, "");
return result;
}
struct dbg_sym_payload_string* dbgfmt_get_symbol_string(struct dbg_sym* bytes)
{
struct dbg_sym_payload_string* result = malloc(sizeof(struct dbg_sym_payload_string));
size_t str_length = bytes->length - 2 * sizeof(uint16_t);
result->data = bfromcstralloc(str_length + 1, "");
return result;
}
bstring getWhitespace(int spaces)
{
bstring whitespace = bfromcstralloc(spaces * 5, "");
while (whitespace->slen < spaces * 5)
{
bcatcstr(whitespace, " ");
}
return whitespace;
}
////////////////////////////////////////////////////////////
/// Create a new item
////////////////////////////////////////////////////////////
static void LexerItemCreate(struct Lexer * LexPtr)
{
if (LexPtr == NULL)
return;
if (LexPtr->OwnItem)
btrunc(LexPtr->Item, 0);
else
// Do not destroy the item
LexPtr->Item = bfromcstralloc(LEXER_BASE_ALLOC, "");
LexPtr->OwnItem = true;
}
/* This function implements Algorithm 5 in Rodland13.
*/
bstring
alder_wordtable_kfmindex_nodeString(alder_wordtable_kfmindex_t *o,
size_t pos)
{
size_t s = size(o);
size_t p = pos;
int k = (int)o->order;
bstring bnodeString = bfromcstralloc(k + 3, " ");
for (int i = 0; i < k; i++) {
size_t x = alder_wordtable_kfmindex_kfmSolve(o, p);
int token = x == 0 ? 4 : (int)(x / s);
p = x == 0 ? 0 : x % s;
char c = alder_wordtable_tokenset_char_of(token);
bconchar(bnodeString, c);
}
return bnodeString;
}
void Handler_notify_credits(Handler *handler, int id, int credits)
{
void *socket = handler->send_socket;
assert(socket && "Socket can't be NULL");
tns_outbuf outbuf = {.buffer = NULL};
bstring payload = NULL;
if(handler->protocol == HANDLER_PROTO_TNET) {
int header_start = tns_render_request_start(&outbuf);
bstring creditsstr = bformat("%d", credits);
tns_render_hash_pair(&outbuf, &HTTP_METHOD, &JSON_METHOD);
tns_render_hash_pair(&outbuf, &DOWNLOAD_CREDITS, creditsstr);
bdestroy(creditsstr);
tns_outbuf_clamp(&outbuf, header_start);
payload = bformat("%s %d @* %s%d:%s,",
bdata(handler->send_ident), id,
bdata(tns_outbuf_to_bstring(&outbuf)),
blength(&CREDITS_MSG), bdata(&CREDITS_MSG));
} else {
bstring headers = bfromcstralloc(PAYLOAD_GUESS, "{");
bcatcstr(headers, "\"METHOD\":\"JSON\",\"");
bconcat(headers, &DOWNLOAD_CREDITS);
bcatcstr(headers, "\":\"");
bformata(headers, "%d", credits);
bcatcstr(headers, "\"}");
payload = bformat("%s %d @* %d:%s,%d:%s,",
bdata(handler->send_ident), id,
blength(headers), bdata(headers),
blength(&CREDITS_MSG), bdata(&CREDITS_MSG));
bdestroy(headers);
}
check(payload != NULL, "Failed to make the payload for credits.");
if(Handler_deliver(socket, bdata(payload), blength(payload)) == -1) {
log_err("Can't tell handler %d giving credits.", id);
}
error: //fallthrough
if(payload) free(payload);
if(outbuf.buffer) free(outbuf.buffer);
}
bstring HexStr(char *data, size_t len)
{
assert(data != NULL && "NULL data pointer");
bstring str = bfromcstralloc(len * 2, "");
check_mem(str);
char *end = data + len;
while (data < end)
{
int rc = bformata(str, "%02hhX", *data++);
check(rc == BSTR_OK, "bformata failed");
}
return str;
error:
bdestroy(str);
return NULL;
}
void sys_err(int pri, char *fn, int ln, int en, const char *fmt, ...) {
if (pri==LOG_DEBUG )
{
bstring bt = bfromcstralloc(128,"");
int sz;
bvformata(sz, bt, fmt, fmt);
if (sz == BSTR_OK) {
if (1) {
fprintf(stderr, "%s: %d: %d (%s) %s\n", fn, ln, en, en ? strerror(en) : "Debug", bt->data);
} else {
if (en)
syslog(pri, "%s: %d: %d (%s) %s", fn, ln, en, strerror(en), bt->data);
else
syslog(pri, "%s: %d: %s", fn, ln, bt->data);
}
}
bdestroy(bt);
}
}
/* Description: Wait for a packet from LINK and return it.
* Author: Albin Severinson
* Date: 03/03/15
*/
bstring get_packet()
{
int rc = 0;
int i = 0;
unsigned char data_length = 0;
char byte = 0;
//Prepare an empty packet
bstring packet = bfromcstralloc(total_packet_size, "");
//Get packet
data_length = get_byte();
//rc = binsertch(packet, 0, 1, data_length);
//check(rc == BSTR_OK, "Failed to add packet length.");
debug("Got packet size: %d", data_length);
//Get rest of packet
for(i = 0;i < data_length;i++){
byte = get_byte();
rc = binsertch(packet, i, 1, byte);
check(rc == BSTR_OK, "Failed to get packet.");
//debug("Got [%d = %d]", i, byte);
}
//Send ACK frame
if(data_length != 0){
rc = send_ack();
check(rc == 0, "Failed to send ACK frame.");
}
debug("[GOT PACKET]: %s", bdata(packet));
return packet;
error:
bdestroy(packet);
return NULL;
}
////////////////////////////////////////////////////////////
/// Lexer initializer (the FILE have to be opened)
////////////////////////////////////////////////////////////
struct Lexer * LexerCreate(FILE * File)
{
struct Lexer * Result = NULL;
if (File != NULL)
{
Result = (struct Lexer*)malloc(sizeof(struct Lexer));
if (Result != NULL)
{
Result->Input = File;
Result->Current = EOF;
Result->HasCurrent = false;
Result->Item = bfromcstralloc(LEXER_BASE_ALLOC, "");
Result->OwnItem = true;
Result->Off = false;
Result->Started = false;
}
}
return Result;
}
void likwid_markerStartRegion(const char* regionTag)
{
if ( ! likwid_init )
{
return;
}
bstring tag = bfromcstralloc(100, regionTag);
LikwidThreadResults* results;
uint64_t res;
int cpu_id = hashTable_get(tag, &results);
bdestroy(tag);
int socket_fd = thread_socketFD[cpu_id];
if (accessClient_mode != DAEMON_AM_DIRECT)
{
if (socket_fd == -1)
{
printf("ERROR: Invalid socket file handle on processor %d. \
Did you call likwid_markerThreadInit() ?\n", cpu_id);
}
}
int main(int argc, char **args){
bstring pull_addr = bfromcstr("tcp://127.0.0.1:8999");
bstring pub_addr = bfromcstr("tcp://127.0.0.1:8998");
mongrel2_ctx *ctx = mongrel2_init(1); // Yes for threads?
mongrel2_socket *pull_socket = mongrel2_pull_socket(ctx,bdata(&SENDER));
mongrel2_connect(pull_socket, bdata(pull_addr));
mongrel2_socket *pub_socket = mongrel2_pub_socket(ctx);
mongrel2_connect(pub_socket, bdata(pub_addr));
const bstring headers = bfromcstr("HTTP/1.1 200 OK\r\nDate: Fri, 07 Jan 2011 01:15:42 GMT\r\nStatus: 200 OK\r\nConnection: close");
mongrel2_request *request;
// Need to set umask to allow file creation... then restore? Not sure!
mode_t process_mask = umask(0);
int retval;
retval = mkfifo("handler_pipe", S_IRUSR);
umask(process_mask);
if(retval != 0){
switch(errno){
case EACCES :
fprintf(stderr,"Insufficient permissions to create fifo handler_pipe");
case EEXIST :
//fprintf(stderr,"handler_pipe already exists. That's cool tho.");
goto no_mkfifo_error;
case ENAMETOOLONG :
fprintf(stderr,"handler_pipe is too long of a name. Unlikely!");
break;
case ENOENT :
fprintf(stderr,"path for handler_pipe does not exist");
break;
case ENOSPC :
fprintf(stderr,"no more room for handler_pipe");
break;
case ENOTDIR :
fprintf(stderr,"path for handler_pipe is not a directory");
break;
case EROFS :
fprintf(stderr,"handler_pipe cannot be created on read only fs");
break;
default:
fprintf(stderr,"Error creating fifo. Not sure what though. Sorry! %d",errno);
break;
}
exit(EXIT_FAILURE);
}
no_mkfifo_error:
fprintf(stdout,"Created handler_pipe AOK\n");
FILE *fifofd = fopen("handler_pipe","r");
if(fifofd == NULL){
fprintf(stderr,"Could not open handler_pipe");
exit(EXIT_FAILURE);
}
size_t read_size;
request = mongrel2_recv(pull_socket);
// A 1k buffer
void* fifo_buffer = calloc(1024,1);
//while(1){
read_size = fread(fifo_buffer, 1024, 1, fifofd);
fprintf(stdout,"read_size from fifo: %zd", read_size); // z is for size_t's... weird!
bdestroy(request->body);
request->body = bfromcstralloc(1024,(const char*)fifo_buffer);
mongrel2_reply_http(pub_socket, request, headers, request->body);
mongrel2_disconnect(pub_socket, request);
//}
mongrel2_request_finalize(request);
bdestroy(headers);
bdestroy(pull_addr);
bdestroy(pub_addr);
mongrel2_close(pull_socket);
mongrel2_close(pub_socket);
mongrel2_deinit(ctx);
return 0;
}
void TranslateToGLSL(HLSLCrossCompilerContext* psContext, GLLang* planguage,const GlExtensions *extensions)
{
bstring glsl;
uint32_t i;
Shader* psShader = psContext->psShader;
GLLang language = *planguage;
const uint32_t ui32InstCount = psShader->ui32InstCount;
const uint32_t ui32DeclCount = psShader->ui32DeclCount;
psContext->indent = 0;
if(language == LANG_DEFAULT)
{
language = ChooseLanguage(psShader);
*planguage = language;
}
glsl = bfromcstralloc (1024, GetVersionString(language));
psContext->glsl = glsl;
psContext->earlyMain = bfromcstralloc (1024, "");
for(i=0; i<NUM_PHASES;++i)
{
psContext->postShaderCode[i] = bfromcstralloc (1024, "");
}
psContext->currentGLSLString = &glsl;
psShader->eTargetLanguage = language;
psShader->extensions = (const struct GlExtensions*)extensions;
psContext->currentPhase = MAIN_PHASE;
if(extensions)
{
if(extensions->ARB_explicit_attrib_location)
bcatcstr(glsl,"#extension GL_ARB_explicit_attrib_location : require\n");
if(extensions->ARB_explicit_uniform_location)
bcatcstr(glsl,"#extension GL_ARB_explicit_uniform_location : require\n");
if(extensions->ARB_shading_language_420pack)
bcatcstr(glsl,"#extension GL_ARB_shading_language_420pack : require\n");
}
ClearDependencyData(psShader->eShaderType, psContext->psDependencies);
AddVersionDependentCode(psContext);
if(psContext->flags & HLSLCC_FLAG_UNIFORM_BUFFER_OBJECT)
{
bcatcstr(glsl, "layout(std140) uniform;\n");
}
//Special case. Can have multiple phases.
if(psShader->eShaderType == HULL_SHADER)
{
int haveInstancedForkPhase = 0;
uint32_t forkIndex = 0;
ConsolidateHullTempVars(psShader);
for(i=0; i < psShader->ui32HSDeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->psHSDecl+i);
}
//control
psContext->currentPhase = HS_CTRL_POINT_PHASE;
if(psShader->ui32HSControlPointDeclCount)
{
bcatcstr(glsl, "//Control point phase declarations\n");
for(i=0; i < psShader->ui32HSControlPointDeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->psHSControlPointPhaseDecl+i);
}
}
if(psShader->ui32HSControlPointInstrCount)
{
SetDataTypes(psContext, psShader->psHSControlPointPhaseInstr, psShader->ui32HSControlPointInstrCount);
bcatcstr(glsl, "void control_point_phase()\n{\n");
psContext->indent++;
for(i=0; i < psShader->ui32HSControlPointInstrCount; ++i)
{
TranslateInstruction(psContext, psShader->psHSControlPointPhaseInstr+i);
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
//fork
psContext->currentPhase = HS_FORK_PHASE;
for(forkIndex = 0; forkIndex < psShader->ui32ForkPhaseCount; ++forkIndex)
{
bcatcstr(glsl, "//Fork phase declarations\n");
for(i=0; i < psShader->aui32HSForkDeclCount[forkIndex]; ++i)
{
TranslateDeclaration(psContext, psShader->apsHSForkPhaseDecl[forkIndex]+i);
if(psShader->apsHSForkPhaseDecl[forkIndex][i].eOpcode == OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT)
{
haveInstancedForkPhase = 1;
}
}
bformata(glsl, "void fork_phase%d()\n{\n", forkIndex);
psContext->indent++;
SetDataTypes(psContext, psShader->apsHSForkPhaseInstr[forkIndex], psShader->aui32HSForkInstrCount[forkIndex]-1);
if(haveInstancedForkPhase)
{
AddIndentation(psContext);
bformata(glsl, "for(int forkInstanceID = 0; forkInstanceID < HullPhase%dInstanceCount; ++forkInstanceID) {\n", forkIndex);
psContext->indent++;
}
//The minus one here is remove the return statement at end of phases.
//This is needed otherwise the for loop will only run once.
ASSERT(psShader->apsHSForkPhaseInstr[forkIndex][psShader->aui32HSForkInstrCount[forkIndex]-1].eOpcode == OPCODE_RET);
for(i=0; i < psShader->aui32HSForkInstrCount[forkIndex]-1; ++i)
{
TranslateInstruction(psContext, psShader->apsHSForkPhaseInstr[forkIndex]+i);
}
if(haveInstancedForkPhase)
{
psContext->indent--;
AddIndentation(psContext);
bcatcstr(glsl, "}\n");
if(psContext->havePostShaderCode[psContext->currentPhase])
{
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Post shader code ---\n");
#endif
bconcat(glsl, psContext->postShaderCode[psContext->currentPhase]);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End post shader code ---\n");
#endif
}
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
//join
psContext->currentPhase = HS_JOIN_PHASE;
if(psShader->ui32HSJoinDeclCount)
{
bcatcstr(glsl, "//Join phase declarations\n");
for(i=0; i < psShader->ui32HSJoinDeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->psHSJoinPhaseDecl+i);
}
}
if(psShader->ui32HSJoinInstrCount)
{
SetDataTypes(psContext, psShader->psHSJoinPhaseInstr, psShader->ui32HSJoinInstrCount);
bcatcstr(glsl, "void join_phase()\n{\n");
psContext->indent++;
for(i=0; i < psShader->ui32HSJoinInstrCount; ++i)
{
TranslateInstruction(psContext, psShader->psHSJoinPhaseInstr+i);
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
bcatcstr(glsl, "void main()\n{\n");
psContext->indent++;
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Start Early Main ---\n");
#endif
bconcat(glsl, psContext->earlyMain);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End Early Main ---\n");
#endif
if(psShader->ui32HSControlPointInstrCount)
{
AddIndentation(psContext);
bcatcstr(glsl, "control_point_phase();\n");
if(psShader->ui32ForkPhaseCount || psShader->ui32HSJoinInstrCount)
{
AddIndentation(psContext);
bcatcstr(glsl, "barrier();\n");
}
}
for(forkIndex = 0; forkIndex < psShader->ui32ForkPhaseCount; ++forkIndex)
{
AddIndentation(psContext);
bformata(glsl, "fork_phase%d();\n", forkIndex);
if(psShader->ui32HSJoinInstrCount || (forkIndex+1 < psShader->ui32ForkPhaseCount))
{
AddIndentation(psContext);
bcatcstr(glsl, "barrier();\n");
}
}
if(psShader->ui32HSJoinInstrCount)
{
AddIndentation(psContext);
bcatcstr(glsl, "join_phase();\n");
}
psContext->indent--;
bcatcstr(glsl, "}\n");
if(psContext->psDependencies)
{
//Save partitioning and primitive type for use by domain shader.
psContext->psDependencies->eTessOutPrim = psShader->sInfo.eTessOutPrim;
psContext->psDependencies->eTessPartitioning = psShader->sInfo.eTessPartitioning;
}
return;
}
if(psShader->eShaderType == DOMAIN_SHADER && psContext->psDependencies)
{
//Load partitioning and primitive type from hull shader.
switch(psContext->psDependencies->eTessOutPrim)
{
case TESSELLATOR_OUTPUT_TRIANGLE_CW:
{
bcatcstr(glsl, "layout(cw) in;\n");
break;
}
case TESSELLATOR_OUTPUT_POINT:
{
bcatcstr(glsl, "layout(point_mode) in;\n");
break;
}
default:
{
break;
}
}
switch(psContext->psDependencies->eTessPartitioning)
{
case TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
{
bcatcstr(glsl, "layout(fractional_odd_spacing) in;\n");
break;
}
case TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
{
bcatcstr(glsl, "layout(fractional_even_spacing) in;\n");
break;
}
default:
{
break;
}
}
}
for(i=0; i < ui32DeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->psDecl+i);
}
bcatcstr(glsl, "void main()\n{\n");
psContext->indent++;
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Start Early Main ---\n");
#endif
bconcat(glsl, psContext->earlyMain);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End Early Main ---\n");
#endif
MarkIntegerImmediates(psContext);
SetDataTypes(psContext, psShader->psInst, ui32InstCount);
for(i=0; i < ui32InstCount; ++i)
{
TranslateInstruction(psContext, psShader->psInst+i);
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
static int
ssh_validate_hostkey(obfsproxyssh_client_session_t *session)
{
obfsproxyssh_t *state = session->client->state;
const char *hkey_method;
bstring trusted_fp;
const char *fp;
bstring fp_s;
int i, len, dlen;
hkey_method = libssh2_session_methods(session->ssh_session,
LIBSSH2_METHOD_HOSTKEY);
if (0 == strcmp(hkey_method, "ssh-rsa"))
trusted_fp = session->hostkey_rsa;
else if (0 == strcmp(hkey_method, "ssh-dss"))
trusted_fp = session->hostkey_dss;
else {
log_f(state, "SSH: Error: Supplied hostkey method is invalid (%s)",
bdata(session->ssh_addr),
hkey_method);
return -1;
}
len = blength(trusted_fp);
switch (len) {
case OBFSPROXYSSH_CLIENT_MD5_FP_LEN:
fp = libssh2_hostkey_hash(session->ssh_session,
LIBSSH2_HOSTKEY_HASH_MD5);
dlen = 16;
break;
case OBFSPROXYSSH_CLIENT_SHA1_FP_LEN:
fp = libssh2_hostkey_hash(session->ssh_session,
LIBSSH2_HOSTKEY_HASH_SHA1);
dlen = 20;
break;
default:
log_f(state, "SSH: Error: Supplied hostkey length is invalid (%s)",
bdata(session->ssh_addr),
bdata(trusted_fp));
return -1;
}
fp_s = bfromcstralloc(len, "");
for (i = 0; i < dlen; i++) {
bformata(fp_s, "%02X", (unsigned char) fp[i]);
if (i != dlen - 1)
bconchar(fp_s, ':');
}
i = bstricmp(trusted_fp, fp_s);
if (0 != i)
log_f(state, "SSH: Error: %s Hostkey mismatch (Got: %s, Expecting: %s)",
bdata(session->ssh_addr),
bdata(trusted_fp),
bdata(fp_s));
else
log_f(state, "SSH: %s Hostkey matched (%s)",
bdata(session->ssh_addr),
bdata(trusted_fp));
return (0 == i) ? 0 : -1;
}
int main (int argc, char * argv[]) {
bstring b = bfromcstr ("Hello WORLDDDD");
if (!b) {
fprintf (stderr, "Out of memory");
} else {
puts ((char *) b->data);
}
bdestroy (b);
b = bfromcstralloc (64, "123456789012345678901234567890123456789012345678901234567890123");
if (b)
{
b->data[63] = 'x';
puts ((char *) b->data);
printf("dump is %s\n", dumpBstring(b));
}
else
{
puts("bfromcstralloc failed");
}
bdestroy (b);
b = blk2bstr ("AWHOLEnewworld", sizeof("wholenewworld")-3);
puts ((char *) b->data);
char *cstr = bstr2cstr(b, '\0');
puts(cstr);
free(cstr);
cstr = bstr2cstr(b, '0');
puts(cstr);
free(cstr);
bstring copy = bstrcpy(b);
printf("copy is %s\n", (char *) copy->data);
bdestroy (b);
b = bfromcstralloc (64, "123456789012345678901234567890123456789012345678901234567890123");
bassign(copy, b);
printf("copy is %s\n", (char *) copy->data);
printf("b is %s\n", (char *) b->data);
bdestroy (b);
b = blk2bstr ("AWHOLEnewworld", sizeof("wholenewworld"));
bassign(copy, b);
printf("copy is %s\n", (char *) copy->data);
printf("b is %s\n", (char *) b->data);
bdestroy(b);
bdestroy(copy);
int i = 0;
b = bfromcstralloc (64, "123456789012345678901234567890123456789012345678901234567890123");
struct bstrList *blist = bsplit(b, '0');
printf("made blist. qty is %d, mlen is %d. entry[0] is %s\n", blist->qty, blist->mlen, blist->entry[0]->data);
for(i=0; i<blist->qty; i++)
{
printf("entry[%d] is %s\n", i, blist->entry[i]->data);
}
bstrListDestroy(blist);
blist = bsplit(b, '\0');
printf("made blist. qty is %d, mlen is %d. entry[0] is %s\n", blist->qty, blist->mlen, blist->entry[0]->data);
for(i=0; i<blist->qty; i++)
{
printf("entry[%d] is %s\n", i, blist->entry[i]->data);
}
bstrListDestroy(blist);
struct tagbstring split = bsStatic ("123");
blist = bsplitstr(b, &split);
printf("made blist. qty is %d, mlen is %d. entry[0] is %s\n", blist->qty, blist->mlen, blist->entry[0]->data);
for(i=0; i<blist->qty; i++)
{
printf("entry[%d] is %s\n", i, blist->entry[i]->data);
}
bdestroy(b);
/*
*
*#define CHUNK 1024 [> read 1024 bytes at a time <]
* char buf[CHUNK];
* FILE *file;
* size_t nread;
*
* file = fopen("./LICENSE", "r");
* if (file) {
* while ((nread = fread(buf, 1, sizeof buf, file)) > 0)
* fwrite(buf, 1, nread, stdout);
* if (ferror(file)) {
* [> deal with error <]
* }
* fclose(file);
* }
*/
FILE *lic_fd = fopen("./LICENSE", "r");
struct bStream *bslic_fd = bsopen((bNread) fread, lic_fd);
bstring lic_bstr = bread( (bNread) fread, lic_fd);
printf("bstring is %s", lic_bstr->data);
return 0;
}
static int
parse_server_xport_options(allium_ptcfg *cfg, const char *options)
{
struct bstrList *l;
struct tagbstring str;
int i;
assert(NULL != cfg);
if ((NULL == options) || (0 == strlen(options)))
return (0);
btfromcstr(str, options);
l = bsplit(&str, ';');
if (NULL == l) {
fprintf(stdout, "ENV-ERROR OOM parsing Transport Options\n");
return (-1);
}
for (i = 0; i < l->qty; /* See next_i */) {
bstring arg_str;
int next_i = i + 1;
if (0 == blength(l->entry[i])) {
out_malformed:
fprintf(stdout, "ENV-ERROR Malformed Transport Option\n");
bstrListDestroy_safe(l);
return (-1);
}
/*
* Allocate arg_str such that realloc will never be called by
* bconcat
*/
arg_str = bfromcstralloc(btlength(str), bdata(l->entry[i]));
if (NULL == arg_str) {
out_oom:
bstrListDestroy_safe(l);
fprintf(stdout, "ENV-ERROR OOM parsing Transport Options\n");
return (-1);
}
while ('\\' == bchar(arg_str, blength(arg_str) - 1) && next_i < l->qty) {
*bdataofs(arg_str, blength(arg_str) - 1) = ';';
if (NULL == l->entry[next_i]) {
next_i++;
break;
}
if (BSTR_ERR == bconcat(arg_str, l->entry[next_i])) {
bdestroy_safe(arg_str);
goto out_oom;
}
next_i++;
}
if (parse_server_xport_option(cfg, arg_str)) {
/*
* XXX: This also will claim that the option is
* malformed if a malloc fails in the subroutine.
* However if that happens, you have bigger problems.
*/
bdestroy_safe(arg_str);
goto out_malformed;
}
i = next_i;
bdestroy_safe(arg_str);
}
bstrListDestroy_safe(l);
return (0);
}
static bstring tr_eval(TextResource tr, trnode_t* node) {
//internally we work with bstrings
trnode_t* tmpNode;
switch(node->type) {
case TRNODE_TEXT:
return bstrcpy(node->textData);
case TRNODE_REPR:
; int match=0;
if (node->condKey) {
assert(node->condValue);
//conditional
char* condkey = bstr2cstr(node->condKey,'\0');
bstring val = ght_get(tr->parameters,strlen(condkey),condkey);
bcstrfree(condkey);
if (val && !bstrcmp(node->condValue, val)) {
//matches
match = 1;
}
} else {
//unconditional, so go too
match=1;
}
if (match) {
return tr_evalKey(tr,node->reprKey->data);
} else
return bfromcstr("");
case TRNODE_STRING:
//these guys have a blob of nodes that needs to be catted together smartly
tmpNode = node->children_list;
bstring tmpStr = bfromcstralloc(32,"");
while(tmpNode) {
bstring childStr = tr_eval(tr,tmpNode);
bconchar(tmpStr,' ');
bconcat(tmpStr,childStr);
bdestroy(childStr);
tmpNode = tmpNode->next;
}
return tmpStr;
case TRNODE_SWITCH:
//look through the children for matching choice
; char* switchVar = bstr2cstr(node->switchVar,'\0');
bstring val = ght_get(tr->parameters,strlen(switchVar),switchVar);
bcstrfree(switchVar);
tmpNode = node->children_list;
while(tmpNode) {
assert(tmpNode->type == TRNODE_STRING);
assert(tmpNode->caseValue);
if (!bstrcmp(tmpNode->caseValue,val)) {
//we match, return this
return tr_eval(tr,tmpNode);
}
//try next
tmpNode = tmpNode->next;
}
return bfromcstr("");
default:
assert(0);
}
assert(0);
return NULL;
}
void TranslateToGLSL(HLSLCrossCompilerContext* psContext, GLLang* planguage,const GlExtensions *extensions)
{
bstring glsl;
uint32_t i;
Shader* psShader = psContext->psShader;
GLLang language = *planguage;
uint32_t ui32InstCount = 0;
uint32_t ui32DeclCount = 0;
psContext->indent = 0;
/*psShader->sPhase[MAIN_PHASE].ui32InstanceCount = 1;
psShader->sPhase[MAIN_PHASE].ppsDecl = hlslcc_malloc(sizeof(Declaration*));
psShader->sPhase[MAIN_PHASE].ppsInst = hlslcc_malloc(sizeof(Instruction*));
psShader->sPhase[MAIN_PHASE].pui32DeclCount = hlslcc_malloc(sizeof(uint32_t));
psShader->sPhase[MAIN_PHASE].pui32InstCount = hlslcc_malloc(sizeof(uint32_t));*/
if(language == LANG_DEFAULT)
{
language = ChooseLanguage(psShader);
*planguage = language;
}
glsl = bfromcstralloc (1024, GetVersionString(language));
psContext->glsl = glsl;
psContext->earlyMain = bfromcstralloc (1024, "");
for(i=0; i<NUM_PHASES;++i)
{
psContext->postShaderCode[i] = bfromcstralloc (1024, "");
}
psContext->currentGLSLString = &glsl;
psShader->eTargetLanguage = language;
psShader->extensions = (const struct GlExtensions*)extensions;
psContext->currentPhase = MAIN_PHASE;
if(extensions)
{
if(extensions->ARB_explicit_attrib_location)
bcatcstr(glsl,"#extension GL_ARB_explicit_attrib_location : require\n");
if(extensions->ARB_explicit_uniform_location)
bcatcstr(glsl,"#extension GL_ARB_explicit_uniform_location : require\n");
if(extensions->ARB_shading_language_420pack)
bcatcstr(glsl,"#extension GL_ARB_shading_language_420pack : require\n");
}
ClearDependencyData(psShader->eShaderType, psContext->psDependencies);
AddVersionDependentCode(psContext);
if(psContext->flags & HLSLCC_FLAG_UNIFORM_BUFFER_OBJECT)
{
bcatcstr(glsl, "layout(std140) uniform;\n");
}
//Special case. Can have multiple phases.
if(psShader->eShaderType == HULL_SHADER)
{
int haveInstancedForkPhase = 0; // Do we have an instanced fork phase?
int isCurrentForkPhasedInstanced = 0; // Is the current fork phase instanced?
const char* asPhaseFuncNames[NUM_PHASES];
uint32_t ui32PhaseFuncCallOrder[3];
uint32_t ui32PhaseCallIndex;
uint32_t ui32Phase;
uint32_t ui32Instance;
asPhaseFuncNames[MAIN_PHASE] = "";
asPhaseFuncNames[HS_GLOBAL_DECL] = "";
asPhaseFuncNames[HS_FORK_PHASE] = "fork_phase";
asPhaseFuncNames[HS_CTRL_POINT_PHASE] = "control_point_phase";
asPhaseFuncNames[HS_JOIN_PHASE] = "join_phase";
ConsolidateHullTempVars(psShader);
for(i=0; i < psShader->asPhase[HS_GLOBAL_DECL].pui32DeclCount[0]; ++i)
{
TranslateDeclaration(psContext, psShader->asPhase[HS_GLOBAL_DECL].ppsDecl[0]+i);
}
for(ui32Phase=HS_CTRL_POINT_PHASE; ui32Phase<NUM_PHASES; ui32Phase++)
{
psContext->currentPhase = ui32Phase;
for(ui32Instance = 0; ui32Instance < psShader->asPhase[ui32Phase].ui32InstanceCount; ++ui32Instance)
{
isCurrentForkPhasedInstanced = 0; //reset for each fork phase for cases we don't have a fork phase instance count opcode.
bformata(glsl, "//%s declarations\n", asPhaseFuncNames[ui32Phase]);
for(i=0; i < psShader->asPhase[ui32Phase].pui32DeclCount[ui32Instance]; ++i)
{
TranslateDeclaration(psContext, psShader->asPhase[ui32Phase].ppsDecl[ui32Instance]+i);
if(psShader->asPhase[ui32Phase].ppsDecl[ui32Instance][i].eOpcode == OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT)
{
haveInstancedForkPhase = 1;
isCurrentForkPhasedInstanced = 1;
}
}
bformata(glsl, "void %s%d()\n{\n", asPhaseFuncNames[ui32Phase], ui32Instance);
psContext->indent++;
SetDataTypes(psContext, psShader->asPhase[ui32Phase].ppsInst[ui32Instance], psShader->asPhase[ui32Phase].pui32InstCount[ui32Instance]-1);
if(isCurrentForkPhasedInstanced)
{
AddIndentation(psContext);
bformata(glsl, "for(int forkInstanceID = 0; forkInstanceID < HullPhase%dInstanceCount; ++forkInstanceID) {\n", ui32Instance);
psContext->indent++;
}
//The minus one here is remove the return statement at end of phases.
//This is needed otherwise the for loop will only run once.
ASSERT(psShader->asPhase[ui32Phase].ppsInst[ui32Instance] [psShader->asPhase[ui32Phase].pui32InstCount[ui32Instance]-1].eOpcode == OPCODE_RET);
for(i=0; i < psShader->asPhase[ui32Phase].pui32InstCount[ui32Instance]-1; ++i)
{
TranslateInstruction(psContext, psShader->asPhase[ui32Phase].ppsInst[ui32Instance]+i, NULL);
}
if(haveInstancedForkPhase)
{
psContext->indent--;
AddIndentation(psContext);
if(isCurrentForkPhasedInstanced)
{
bcatcstr(glsl, "}\n");
}
if(psContext->havePostShaderCode[psContext->currentPhase])
{
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Post shader code ---\n");
#endif
bconcat(glsl, psContext->postShaderCode[psContext->currentPhase]);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End post shader code ---\n");
#endif
}
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
}
bcatcstr(glsl, "void main()\n{\n");
psContext->indent++;
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Start Early Main ---\n");
#endif
bconcat(glsl, psContext->earlyMain);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End Early Main ---\n");
#endif
ui32PhaseFuncCallOrder[0] = HS_CTRL_POINT_PHASE;
ui32PhaseFuncCallOrder[1] = HS_FORK_PHASE;
ui32PhaseFuncCallOrder[2] = HS_JOIN_PHASE;
for(ui32PhaseCallIndex=0; ui32PhaseCallIndex<3; ui32PhaseCallIndex++)
{
ui32Phase = ui32PhaseFuncCallOrder[ui32PhaseCallIndex];
for(ui32Instance = 0; ui32Instance < psShader->asPhase[ui32Phase].ui32InstanceCount; ++ui32Instance)
{
AddIndentation(psContext);
bformata(glsl, "%s%d();\n", asPhaseFuncNames[ui32Phase], ui32Instance);
if(ui32Phase == HS_FORK_PHASE)
{
if(psShader->asPhase[HS_JOIN_PHASE].ui32InstanceCount ||
(ui32Instance+1 < psShader->asPhase[HS_FORK_PHASE].ui32InstanceCount))
{
AddIndentation(psContext);
bcatcstr(glsl, "barrier();\n");
}
}
}
}
psContext->indent--;
bcatcstr(glsl, "}\n");
if(psContext->psDependencies)
{
//Save partitioning and primitive type for use by domain shader.
psContext->psDependencies->eTessOutPrim = psShader->sInfo.eTessOutPrim;
psContext->psDependencies->eTessPartitioning = psShader->sInfo.eTessPartitioning;
}
return;
}
if(psShader->eShaderType == DOMAIN_SHADER && psContext->psDependencies)
{
//Load partitioning and primitive type from hull shader.
switch(psContext->psDependencies->eTessOutPrim)
{
case TESSELLATOR_OUTPUT_TRIANGLE_CW:
{
bcatcstr(glsl, "layout(cw) in;\n");
break;
}
case TESSELLATOR_OUTPUT_POINT:
{
bcatcstr(glsl, "layout(point_mode) in;\n");
break;
}
default:
{
break;
}
}
switch(psContext->psDependencies->eTessPartitioning)
{
case TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
{
bcatcstr(glsl, "layout(fractional_odd_spacing) in;\n");
break;
}
case TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
{
bcatcstr(glsl, "layout(fractional_even_spacing) in;\n");
break;
}
default:
{
break;
}
}
}
ui32InstCount = psShader->asPhase[MAIN_PHASE].pui32InstCount[0];
ui32DeclCount = psShader->asPhase[MAIN_PHASE].pui32DeclCount[0];
for(i=0; i < ui32DeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->asPhase[MAIN_PHASE].ppsDecl[0]+i);
}
if(psContext->psShader->ui32NumDx9ImmConst)
{
bformata(psContext->glsl, "vec4 ImmConstArray [%d];\n", psContext->psShader->ui32NumDx9ImmConst);
}
bcatcstr(glsl, "void main()\n{\n");
psContext->indent++;
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Start Early Main ---\n");
#endif
bconcat(glsl, psContext->earlyMain);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End Early Main ---\n");
#endif
MarkIntegerImmediates(psContext);
SetDataTypes(psContext, psShader->asPhase[MAIN_PHASE].ppsInst[0], ui32InstCount);
for(i=0; i < ui32InstCount; ++i)
{
TranslateInstruction(psContext, psShader->asPhase[MAIN_PHASE].ppsInst[0]+i, i+1 < ui32InstCount ? psShader->asPhase[MAIN_PHASE].ppsInst[0]+i+1 : 0);
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
bstring get_signer_pubkey(bstring url)
{
CURL *curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, url->data);
bstring result = bfromcstr("");
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, save_incoming_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, result);
bstring error = bfromcstralloc(CURL_ERROR_SIZE, "");
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, bdata(error));
CURLcode rc = curl_easy_perform(curl);
if (rc != CURLE_OK)
{
fprintf(stderr, "Error obtaining token: %s\n", bdata(error));
exit(1);
}
long response_code;
rc = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
if (rc != CURLE_OK)
{
fprintf(stderr, "Error obtaining response code\n");
return 0;
}
if (response_code == 403)
{
fprintf(stderr, "Permission denied.\n");
return 0;
}
if (response_code >= 300)
{
fprintf(stderr, "Invalid response code %ld from server\n", response_code);
return 0;
}
// printf("rc=%d '%s'\n", rc, result->data);
curl_easy_cleanup(curl);
curl = 0;
bdestroy(error);
json_settings settings = { 0 } ;
char json_error[json_error_max + 1];
json_value *ret = json_parse_ex(&settings, bdata(result), blength(result), json_error);
if (ret->type != json_object)
return 0;
int i;
bstring pubkey = 0;
for (i = 0; i < ret->u.object.length; i++)
{
if (strcmp(ret->u.object.values[i].name, "pubkey") == 0)
{
json_value *t = ret->u.object.values[i].value;
pubkey = bfromcstr(t->u.string.ptr);
}
}
json_value_free(ret);
bdestroy(result);
return pubkey;
}
int validate_token(bstring token)
{
int i;
OpenSSL_add_all_algorithms();
struct bstrList *parts = bsplit(token, '|');
dictionary *dict = dictionary_new(10);
bstring sig = bfromcstr("sig");
bstring to_sign = bfromcstr("");
for (i = 0; i < parts->qty; i++)
{
printf("%d: %s\n", i, parts->entry[i]->data);
struct bstrList *x = bsplit(parts->entry[i], '=');
if (x->qty == 2)
{
if (bstrcmp(x->entry[0], sig) != 0)
{
if (blength(to_sign) > 0)
bconchar(to_sign, '|');
bconcat(to_sign, parts->entry[i]);
}
dictionary_set(dict, bdata(x->entry[0]), bdata(x->entry[1]));
}
bstrListDestroy(x);
}
bstrListDestroy(parts);
parts = 0;
bdestroy(sig);
dictionary_dump(dict, stdout);
printf("to sign: '%s'\n", bdata(to_sign));
// Check signing subject (need to know the valid values)
char *subj = dictionary_get(dict, "SigningSubject", 0);
if (!subj)
{
fprintf(stderr, "could not get signing subject\n");
return 0;
}
char *sigstr = dictionary_get(dict, "sig", 0);
printf("sig to verify is %s\n", sigstr);
bstring binsig = bfromcstralloc(strlen(sigstr) / 2, "");
char *s, *e;
for (s = sigstr, e = sigstr + strlen(sigstr); s < e; s += 2)
{
char n[3];
n[0] = s[0];
n[1] = s[1];
n[2] = 0;
long int v = strtol(n, 0, 16);
// printf("n=%s v=%ld %lx\n", n, v, v);
bconchar(binsig, (char) v);
}
unsigned char *sha = SHA1((const unsigned char *) to_sign->data, to_sign->slen, 0);
bdestroy(to_sign);
bstring bsubj = bfromcstr(subj);
bstring pubkey = get_signer_pubkey(bsubj);
BIO *bio = BIO_new(BIO_s_mem());
BIO_puts(bio, bdata(pubkey));
RSA *rsa = PEM_read_bio_RSAPublicKey(bio, 0, 0, 0);
int rc = RSA_verify(NID_sha1, sha, SHA_DIGEST_LENGTH, binsig->data, binsig->slen, rsa);
printf("rc=%d\n", rc);
bdestroy(bsubj);
bdestroy(binsig);
bdestroy(pubkey);
BIO_free(bio);
RSA_free(rsa);
dictionary_del(dict);
EVP_cleanup();
return rc;
}
static bstring read_string(char * src, size_t length)
{
int utf8_char;
char hex_num[7] = "0x0000";
char * end = src + length;
bstring s = bfromcstralloc(length, "");
char * dst = bdata(s);
if (* src == '"') src++;
while (src < end) {
if (* src != '\\') {
* dst = * src;
dst++;
} else {
src++;
if (* src == '"') {
* dst = '"';
dst++;
} else if (* src == '\\') {
* dst = '\\';
dst++;
} else if (* src == '/') {
* dst = '/';
dst++;
} else if (* src == 'b') {
* dst = '\b';
dst++;
} else if (* src == 'f') {
* dst = '\f';
dst++;
} else if (* src == 'n') {
* dst = '\n';
dst++;
} else if (* src == 'r') {
* dst = '\r';
dst++;
} else if (* src == 't') {
* dst = '\t';
dst++;
} else if (* src == 'u') {
memcpy(hex_num + 2, src + 1, 4);
sscanf(hex_num, "%x", &utf8_char);
if (utf8_char <= UTF8_2_BYTE_LIMIT) {
* dst = UTF8_BYTE_1_OF_2(utf8_char);
dst++;
* dst = UTF8_BYTE_2_OF_2(utf8_char);
dst++;
} else {
* dst = UTF8_BYTE_1_OF_3(utf8_char);
dst++;
* dst = UTF8_BYTE_2_OF_3(utf8_char);
dst++;
* dst = UTF8_BYTE_3_OF_3(utf8_char);
dst++;
}
src += 4;
}
}
src++;
}
s->slen = dst - bdata(s);
return s;
}
