void Transport::replaceHeader(CStrRef header) {
String name;
const char *value;
if (splitHeader(header, name, value)) {
replaceHeader(name.data(), value);
}
}
void fileDLLToNet(char* filename)
{
char* header = NULL;
int headerLen = 0;
char* data = NULL;
int dataLen = readBMP(filename,&header,&headerLen,&data);
if (dataLen >0)
{
message headerMessage;
headerMessage.code = END_HEADER;
headerMessage.data = (char*)malloc(headerLen*sizeof(char));
memcpy(headerMessage.data,header,headerLen);
headerMessage.dataLen = headerLen;
packet* headerPackets = NULL;
int headerPacketsLen = splitHeader(headerMessage,&headerPackets);
int k;
for (k = 0; k<headerPacketsLen; k++)
{
fromDLL(headerPackets[k]);
free(headerPackets[k].mess.data);
}
free(headerPackets);
free(headerMessage.data);
message dataMessage;
dataMessage.code = END_FILE;
dataMessage.data = (char*)malloc(dataLen*sizeof(char));
memcpy(dataMessage.data,data,dataLen);
dataMessage.dataLen = dataLen;
packet* dataPackets = NULL;
int dataPacketsLen = splitFile(dataMessage,&dataPackets);
for (k = 0; k<dataPacketsLen; k++)
{
fromDLL(dataPackets[k]);
free(dataPackets[k].mess.data);
}
free(dataPackets);
free(dataMessage.data);
}
else
printf("ERROR: Test file doesn't exist.\n");
free(header);
free(data);
}
/* GC_arrayCopy (ad, as, as, ss, l)
*
* Copy l elements of as starting at ss to ad starting at as.
*/
void GC_arrayCopy (GC_state s, pointer ad, size_t ds, pointer as, size_t ss, size_t l) {
GC_header header;
uint16_t bytesNonObjptrs;
uint16_t numObjptrs;
GC_objectTypeTag tag;
size_t eltSize;
header = getHeader (ad);
splitHeader(s, header, &tag, NULL, &bytesNonObjptrs, &numObjptrs);
assert (tag == ARRAY_TAG);
eltSize = bytesNonObjptrs + (numObjptrs * OBJPTR_SIZE);
GC_memmove (as + eltSize * ss, ad + eltSize * ds, eltSize * l);
}
pointer indexArrayAtObjptrIndex (GC_state s, pointer a,
GC_arrayCounter arrayIndex,
uint32_t objptrIndex) {
GC_header header;
uint16_t bytesNonObjptrs;
uint16_t numObjptrs;
GC_objectTypeTag tag;
header = getHeader (a);
splitHeader(s, header, &tag, NULL, &bytesNonObjptrs, &numObjptrs);
assert (tag == ARRAY_TAG);
return a
+ (arrayIndex * (bytesNonObjptrs + (numObjptrs * OBJPTR_SIZE)))
+ bytesNonObjptrs
+ (objptrIndex * OBJPTR_SIZE);
}
size_t sizeofThread (GC_state s) {
size_t res;
res = GC_NORMAL_METADATA_SIZE + sizeof (struct GC_thread);
res = align (res, s->alignment);
if (DEBUG) {
size_t check;
uint16_t bytesNonObjptrs, numObjptrs;
splitHeader (s, GC_THREAD_HEADER, NULL, NULL, &bytesNonObjptrs, &numObjptrs);
check = GC_NORMAL_METADATA_SIZE + (bytesNonObjptrs + (numObjptrs * OBJPTR_SIZE));
if (DEBUG_DETAILED)
fprintf (stderr,
"sizeofThread: res = %"PRIuMAX" check = %"PRIuMAX"\n",
(uintmax_t)res, (uintmax_t)check);
assert (check == res);
}
assert (isAligned (res, s->alignment));
return res;
}
/**
* \fn int getIfFileHasModified(char *id, char *header, char *fileName, FILE *log)
* \brief Permet de savoir si le fichier courant a été modifier.
*
* \param id Identifiant du descripteur.
* \param fileName Chemin du fichier.
* \param log Fichier de log.
* \return -1 les information sont vide, ou ficheir non trouver.
*/
int getIfFileHasModified(char *id, char *fileName, FILE *log) {
char buffer[BUFFER_SIZE] = {0};
char header[BUFFER_SIZE] = {0};
char currentID[BUFFER_SIZE] = {0};
char date[BUFFER_SIZE] = {0};
char fileDate[BUFFER_SIZE] = {0};
char headerID[BUFFER_SIZE] = {0};
FILE *soundBase = fopen("Bases/base_descripteur_audio.base", "r");
int nbBars;
int nbWindows;
struct stat st;
if(stat(fileName, &st) == -1) {
fprintf(log, "STAT ERROR ");
return(-1);
}
while(!feof(soundBase)) {
fgets(buffer, BUFFER_SIZE, soundBase);
if(buffer[0] != 'I') {
continue;
}
getStringUntil(buffer, currentID, '\t');
if(strcmp(currentID, id) == 0) {
strcpy(header, buffer);
splitHeader(header, headerID, &nbBars, &nbWindows, date);
splitDate(ctime(&st.st_mtime), fileDate);
if(strcmp(date, fileDate) == 0) {
fclose(soundBase);
return(1);
} else {
return(0);
}
}
memset(currentID, 0, BUFFER_SIZE);
}
fclose(soundBase);
return(-1);
}
void HttpResponseParser::consume () {
String line;
while (true) {
switch (mState){
case HP_START:{
if (mInputBuffer.empty()) return;
bool suc = consumeLine (&line);
if (!suc || mReady) return;
if (sscanf (line.c_str(), "HTTP/1.0 %d", &mResponse->resultCode) == 1) {
mResponse->httpVersion = HTTP_10;
} else if (sscanf (line.c_str(), "HTTP/1.1 %d", &mResponse->resultCode) == 1) {
mResponse->httpVersion = HTTP_11;
} else {
return fail (error::BadProtocol, "Bad protocol start");
}
Log (LogInfo) << LOGID << "Response Code: " << mResponse->resultCode << " version= " << mResponse->httpVersion << std::endl;
if (mResponse->resultCode == 100) {
// it's a plain proceed, ignoring
break;
}
mState = HP_INHEADERS;
break;
}
case HP_INHEADERS:{
if (mInputBuffer.empty()) return;
bool suc = consumeLine (&line);
if (!suc || mReady) return;
if (line.empty()) {
mState = HP_INCONTENT;
if (mResponse->headers.count("Content-Length") > 0){
String cl = mResponse->headers["Content-Length"];
try {
mContentLength = boost::lexical_cast<size_t> (cl);
mContentLengthSet = true;
} catch (boost::bad_lexical_cast & e) {
Log (LogInfo) << LOGID << "Could not cast content length" << std::endl;
}
}
if (mResponse->headers.count("Transfer-Encoding") > 0){
String te = mResponse->headers["Transfer-Encoding"];
if (te == "chunked" || te == "Chunked" || te == "CHUNKED"){
mChunkedEncoding = true;
mState = HP_INCONTENT_CHUNKBEGIN;
} else {
Log (LogWarning) << LOGID << "Unknown transfer encoding " << te << std::endl;
}
}
if (!mContentLengthSet && !mChunkedEncoding) {
return fail (error::BadProtocol, "Neither length set nor chunked encoding available, aborting");
}
Log (LogInfo) << LOGID << "Finished with header" << std::endl;
break;
}
String key, value;
suc = splitHeader (line, &key, &value);
if (!suc) {
return fail (error::BadProtocol, "Strange protocol during header splitting");
}
mResponse->headers[key] = value;
// Log (LogInfo) << LOGID << "Parsed Header: " << key << " -> " << value << std::endl;
break;
}
case HP_INCONTENT:
if (mInputBuffer.size() < mContentLength){
// not enough, wait...
return;
}
mResponse->data = createByteArrayPtr();
if (mInputBuffer.size() == mContentLength) {
mResponse->data->swap(mInputBuffer);
} else {
mResponse->data->append(mInputBuffer.const_c_array(), mContentLength);
mInputBuffer.l_truncate(mContentLength);
}
mReady = true;
mResult = NoError;
Log (LogInfo) << LOGID << "Ready, read " << mContentLength << std::endl;
return;
case HP_INCONTENT_CHUNKBEGIN:{
if (mInputBuffer.empty()) return;
bool suc = consumeLine (&line);
if (!suc) {
return fail (error::BadProtocol, "Awaited a chunk line");
}
// Log (LogInfo) << LOGID << "Read this as a chunk line: " << line << " len=" << line.size() << std::endl;
if (line.empty())
break; // try it again
// Chunk: Hexadecimal Length and then possiblly a ';' and some comment
unsigned int l;
int parsed = sscanf (line.c_str(), "%x", &l);
if (parsed < 1) {
return fail (error::BadProtocol, "Awaited hexadecimal chunk length");
}
if (l == 0) {
mState = HP_INFOOTERS;
break;
}
// Log (LogInfo) << LOGID << "Len=" << l << std::endl;
mContentLength = l;
mState = HP_INCONTENT_CHUNK;
break;
}
case HP_INCONTENT_CHUNK: {
if (mInputBuffer.size() < mContentLength) return; // wait
if (!mResponse->data)
mResponse->data = createByteArrayPtr();
mResponse->data->append(mInputBuffer.c_array(), mContentLength);
mInputBuffer.l_truncate(mContentLength);
mState = HP_INCONTENT_CHUNKBEGIN;
break;
}
case HP_INFOOTERS:{
bool suc = consumeLine (&line);
if (!suc || mReady) return;
if (line.empty()){
mReady = true;
Log (LogInfo) << LOGID << "Ready." << std::endl;
return;
}
Log (LogInfo) << LOGID << "Ignoring footer line: " << line << std::endl;
break;
}
}
}
}
/* dfsMarkByMode (s, r, m, shc, slw)
*
* Sets all the mark bits in the object graph pointed to by r.
*
* If m is MARK_MODE, it sets the bits to 1.
* If m is UNMARK_MODE, it sets the bits to 0.
*
* If shc, it hash-conses the objects marked.
*
* If slw, it links the weak objects marked.
*
* It returns the total size in bytes of the objects marked.
*/
size_t dfsMarkByMode (GC_state s, pointer root,
GC_markMode mode,
bool shouldHashCons,
bool shouldLinkWeaks) {
GC_header mark; /* Used to set or clear the mark bit. */
size_t size; /* Total number of bytes marked. */
pointer cur; /* The current object being marked. */
pointer prev; /* The previous object on the mark stack. */
pointer next; /* The next object to mark. */
pointer todo; /* A pointer to the pointer in cur to next. */
GC_header header;
GC_header* headerp;
uint16_t bytesNonObjptrs;
uint16_t numObjptrs;
GC_objectTypeTag tag;
uint32_t objptrIndex; /* The i'th pointer in the object (element) being marked. */
GC_header nextHeader;
GC_header* nextHeaderp;
GC_arrayCounter arrayIndex;
pointer top; /* The top of the next stack frame to mark. */
GC_returnAddress returnAddress;
GC_frameLayout frameLayout;
GC_frameOffsets frameOffsets;
if (isPointerMarkedByMode (root, mode))
/* Object has already been marked. */
return 0;
mark = (MARK_MODE == mode) ? MARK_MASK : 0;
size = 0;
cur = root;
prev = NULL;
headerp = getHeaderp (cur);
header = *headerp;
goto mark;
markNext:
/* cur is the object that was being marked.
* prev is the mark stack.
* next is the unmarked object to be marked.
* nextHeaderp points to the header of next.
* nextHeader is the header of next.
* todo is a pointer to the pointer inside cur that points to next.
*/
if (DEBUG_DFS_MARK)
fprintf (stderr,
"markNext"
" cur = "FMTPTR" next = "FMTPTR
" prev = "FMTPTR" todo = "FMTPTR"\n",
(uintptr_t)cur, (uintptr_t)next,
(uintptr_t)prev, (uintptr_t)todo);
assert (not isPointerMarkedByMode (next, mode));
assert (nextHeaderp == getHeaderp (next));
assert (nextHeader == getHeader (next));
// assert (*(pointer*) todo == next);
assert (fetchObjptrToPointer (todo, s->heap.start) == next);
headerp = nextHeaderp;
header = nextHeader;
// *(pointer*)todo = prev;
storeObjptrFromPointer (todo, prev, s->heap.start);
prev = cur;
cur = next;
mark:
if (DEBUG_DFS_MARK)
fprintf (stderr, "mark cur = "FMTPTR" prev = "FMTPTR" mode = %s\n",
(uintptr_t)cur, (uintptr_t)prev,
(mode == MARK_MODE) ? "mark" : "unmark");
/* cur is the object to mark.
* prev is the mark stack.
* headerp points to the header of cur.
* header is the header of cur.
*/
assert (not isPointerMarkedByMode (cur, mode));
assert (header == getHeader (cur));
assert (headerp == getHeaderp (cur));
header ^= MARK_MASK;
/* Store the mark. In the case of an object that contains a pointer to
* itself, it is essential that we store the marked header before marking
* the internal pointers (markInNormal below). If we didn't, then we
* would see the object as unmarked and traverse it again.
*/
*headerp = header;
splitHeader (s, header, &tag, NULL, &bytesNonObjptrs, &numObjptrs);
if (NORMAL_TAG == tag) {
size +=
GC_NORMAL_HEADER_SIZE
+ bytesNonObjptrs
+ (numObjptrs * OBJPTR_SIZE);
if (0 == numObjptrs) {
/* There is nothing to mark. */
normalDone:
if (shouldHashCons)
cur = hashConsPointer (s, cur, TRUE);
goto ret;
}
todo = cur + bytesNonObjptrs;
objptrIndex = 0;
markInNormal:
if (DEBUG_DFS_MARK)
fprintf (stderr, "markInNormal objptrIndex = %"PRIu32"\n", objptrIndex);
assert (objptrIndex < numObjptrs);
// next = *(pointer*)todo;
next = fetchObjptrToPointer (todo, s->heap.start);
if (not isPointer (next)) {
markNextInNormal:
assert (objptrIndex < numObjptrs);
objptrIndex++;
if (objptrIndex == numObjptrs) {
/* Done. Clear out the counters and return. */
*headerp = header & ~COUNTER_MASK;
goto normalDone;
}
todo += OBJPTR_SIZE;
goto markInNormal;
}
nextHeaderp = getHeaderp (next);
nextHeader = *nextHeaderp;
if (mark == (nextHeader & MARK_MASK)) {
if (shouldHashCons)
shareObjptr (s, (objptr*)todo);
goto markNextInNormal;
}
*headerp = (header & ~COUNTER_MASK) | (objptrIndex << COUNTER_SHIFT);
goto markNext;
} else if (WEAK_TAG == tag) {
/* Store the marked header and don't follow any pointers. */
if (shouldLinkWeaks) {
GC_weak w;
w = (GC_weak)(cur + offsetofWeak (s));
if (DEBUG_WEAK)
fprintf (stderr, "marking weak "FMTPTR" ",
(uintptr_t)w);
if (isObjptr (w->objptr)) {
if (DEBUG_WEAK)
fprintf (stderr, "linking\n");
w->link = s->weaks;
s->weaks = w;
} else {
if (DEBUG_WEAK)
fprintf (stderr, "not linking\n");
}
}
goto ret;
} else if (ARRAY_TAG == tag) {
/* When marking arrays:
* arrayIndex is the index of the element to mark.
* cur is the pointer to the array.
* objptrIndex is the index of the pointer within the element
* (i.e. the i'th pointer is at index i).
* todo is the start of the element.
*/
size +=
GC_ARRAY_HEADER_SIZE
+ sizeofArrayNoHeader (s, getArrayLength (cur), bytesNonObjptrs, numObjptrs);
if (0 == numObjptrs or 0 == getArrayLength (cur)) {
/* There is nothing to mark. */
arrayDone:
if (shouldHashCons)
cur = hashConsPointer (s, cur, TRUE);
goto ret;
}
/* Begin marking first element. */
arrayIndex = 0;
todo = cur;
markArrayElt:
assert (arrayIndex < getArrayLength (cur));
objptrIndex = 0;
/* Skip to the first pointer. */
todo += bytesNonObjptrs;
markInArray:
if (DEBUG_DFS_MARK)
fprintf (stderr, "markInArray arrayIndex = %"PRIxARRCTR" objptrIndex = %"PRIu32"\n",
arrayIndex, objptrIndex);
assert (arrayIndex < getArrayLength (cur));
assert (objptrIndex < numObjptrs);
assert (todo == indexArrayAtObjptrIndex (s, cur, arrayIndex, objptrIndex));
// next = *(pointer*)todo;
next = fetchObjptrToPointer (todo, s->heap.start);
if (not (isPointer(next))) {
markNextInArray:
assert (arrayIndex < getArrayLength (cur));
assert (objptrIndex < numObjptrs);
assert (todo == indexArrayAtObjptrIndex (s, cur, arrayIndex, objptrIndex));
todo += OBJPTR_SIZE;
objptrIndex++;
if (objptrIndex < numObjptrs)
goto markInArray;
arrayIndex++;
if (arrayIndex < getArrayLength (cur))
goto markArrayElt;
/* Done. Clear out the counters and return. */
*getArrayCounterp (cur) = 0;
*headerp = header & ~COUNTER_MASK;
goto arrayDone;
}
nextHeaderp = getHeaderp (next);
nextHeader = *nextHeaderp;
if (mark == (nextHeader & MARK_MASK)) {
if (shouldHashCons)
shareObjptr (s, (objptr*)todo);
goto markNextInArray;
}
/* Recur and mark next. */
*getArrayCounterp (cur) = arrayIndex;
*headerp = (header & ~COUNTER_MASK) | (objptrIndex << COUNTER_SHIFT);
goto markNext;
} else {
assert (STACK_TAG == tag);
size +=
GC_STACK_HEADER_SIZE
+ sizeof (struct GC_stack) + ((GC_stack)cur)->reserved;
top = getStackTop (s, (GC_stack)cur);
assert (((GC_stack)cur)->used <= ((GC_stack)cur)->reserved);
markInStack:
/* Invariant: top points just past the return address of the frame
* to be marked.
*/
assert (getStackBottom (s, (GC_stack)cur) <= top);
if (DEBUG_DFS_MARK)
fprintf (stderr, "markInStack top = %"PRIuMAX"\n",
(uintmax_t)(top - getStackBottom (s, (GC_stack)cur)));
if (top == getStackBottom (s, (GC_stack)(cur)))
goto ret;
objptrIndex = 0;
returnAddress = *(GC_returnAddress*) (top - GC_RETURNADDRESS_SIZE);
frameLayout = getFrameLayoutFromReturnAddress (s, returnAddress);
frameOffsets = frameLayout->offsets;
((GC_stack)cur)->markTop = top;
markInFrame:
if (objptrIndex == frameOffsets [0]) {
top -= frameLayout->size;
goto markInStack;
}
todo = top - frameLayout->size + frameOffsets [objptrIndex + 1];
// next = *(pointer*)todo;
next = fetchObjptrToPointer (todo, s->heap.start);
if (DEBUG_DFS_MARK)
fprintf (stderr,
" offset %u todo "FMTPTR" next = "FMTPTR"\n",
frameOffsets [objptrIndex + 1],
(uintptr_t)todo, (uintptr_t)next);
if (not isPointer (next)) {
objptrIndex++;
goto markInFrame;
}
nextHeaderp = getHeaderp (next);
nextHeader = *nextHeaderp;
if (mark == (nextHeader & MARK_MASK)) {
objptrIndex++;
if (shouldHashCons)
shareObjptr (s, (objptr*)todo);
goto markInFrame;
}
((GC_stack)cur)->markIndex = objptrIndex;
goto markNext;
}
assert (FALSE);
ret:
/* Done marking cur, continue with prev.
* Need to set the pointer in the prev object that pointed to cur
* to point back to prev, and restore prev.
*/
if (DEBUG_DFS_MARK)
fprintf (stderr, "return cur = "FMTPTR" prev = "FMTPTR"\n",
(uintptr_t)cur, (uintptr_t)prev);
assert (isPointerMarkedByMode (cur, mode));
if (NULL == prev)
return size;
next = cur;
cur = prev;
headerp = getHeaderp (cur);
header = *headerp;
splitHeader (s, header, &tag, NULL, &bytesNonObjptrs, &numObjptrs);
/* It's impossible to get a WEAK_TAG here, since we would never
* follow the weak object pointer.
*/
assert (WEAK_TAG != tag);
if (NORMAL_TAG == tag) {
todo = cur + bytesNonObjptrs;
objptrIndex = (header & COUNTER_MASK) >> COUNTER_SHIFT;
todo += objptrIndex * OBJPTR_SIZE;
// prev = *(pointer*)todo;
prev = fetchObjptrToPointer (todo, s->heap.start);
// *(pointer*)todo = next;
storeObjptrFromPointer (todo, next, s->heap.start);
if (shouldHashCons)
markIntergenerationalPointer (s, (pointer*)todo);
goto markNextInNormal;
} else if (ARRAY_TAG == tag) {
