void withLock(std::mutex & m, Function f) { m.lock(); f(); m.unlock(); }
void lockStatistics() { gTatisticsCppMutex.lock(); }
void lock() { check_for_hierarchy_violation(); internal_mutex.lock(); update_hierarchy_value(); }
// Internal thread for updating the console. void lConsole::Int_UpdateThread() { static std::chrono::milliseconds UpdateDelay(500); while (true) { // Delay so we don't waste time updating. std::this_thread::sleep_for(UpdateDelay); // If we have a stream handle. if (StreamHandle == nullptr || !ShouldPrintScrollback) continue; // Clear the console. #ifdef _WIN32 // Aparently system("cls") is bad practice as it spawns a shell. COORD topLeft = { 0, 0 }; HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_SCREEN_BUFFER_INFO screen; DWORD written; GetConsoleScreenBufferInfo(console, &screen); FillConsoleOutputCharacterA( console, ' ', screen.dwSize.X * screen.dwSize.Y, topLeft, &written ); FillConsoleOutputAttribute( console, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE, screen.dwSize.X * screen.dwSize.Y, topLeft, &written ); SetConsoleCursorPosition(console, topLeft); #else // But nix can use ANSI escapecodes. // CSI[2J to clear the console. // CSI[H to reset the cursor. fprintf(stdout, "\x1B[2J\x1B[H"); #endif // Save the old color settings. static CONSOLE_SCREEN_BUFFER_INFO OldTextColor; GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &OldTextColor); // For each line in the scrollback. ThreadSafe.lock(); for (uint32_t i = 0; i < ScrollbackLineCount; ++i) { // Set the output strings color. SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), CompatibleRGBA(ScrollbackLines[i].RGBA)); // Search the string for progress bars. for (uint32_t c = 0; c < ProgressbarCount; ++c) { if (strstr(ScrollbackLines[i].String, Progressbars[c].ProgressToken)) { static char ProgressBuffer[257]; memset(ProgressBuffer, 0, 257); // Create the buffer. for (int32_t k = 0; k < (int32_t)min(INT32_MAX, strlen(ScrollbackLines[i].String)) - 1; ++k) { // Copy all the characters up until the token. if (ScrollbackLines[i].String[k + 0] == Progressbars[c].ProgressToken[0] && ScrollbackLines[i].String[k + 1] == Progressbars[c].ProgressToken[1]) { ProgressBuffer[k] = ScrollbackLines[i].String[k]; } else { // Copy the progress bar into the buffer. // TODO: Use the bar type. strcpy(&ProgressBuffer[c], GetProgress(0, Progressbars[c].CurrentValue, Progressbars[c].EndValue)); break; } } // Print the formated buffer. printf(ProgressBuffer); printf("\n"); goto LABEL_PRINT_DONE; } } // Print the string since there's no progress bar. printf(ScrollbackLines[i].String); printf("\n"); LABEL_PRINT_DONE:; } // Reset the color. SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), OldTextColor.wAttributes); ThreadSafe.unlock(); } }
void QueryWorld::updateBuffer() { m_copyWorldLock.lock(); m_queryWorld = m_copyWorld; m_copyWorldLock.unlock(); }
void DumpPacket(DWORD packetType, DWORD connectionId, DWORD opcode, BYTE opcodeSize, DWORD size, BYTE* buffer) { mtx.lock(); // gets the time time_t rawTime; time(&rawTime); DWORD tickCount = GetTickCount(); if (!fileDump) { tm* date = localtime(&rawTime); // basic file name format: char fileName[MAX_PATH]; // removes the DLL name from the path PathRemoveFileSpec(dllPath); // fills the basic file name format _snprintf(fileName, MAX_PATH, "wowsniff_%s_%u_%u_%d-%02d-%02d_%02d-%02d-%02d.pkt", hookInfo.locale, wowInfo.expansion, wowInfo.build, date->tm_year + 1900, date->tm_mon + 1, date->tm_mday, date->tm_hour, date->tm_min, date->tm_sec); // some info printf("Sniff dump: %s\n\n", fileName); char fullFileName[MAX_PATH]; _snprintf(fullFileName, MAX_PATH, "%s\\%s", dllPath, fileName); fileDump = fopen(fullFileName, "wb"); // PKT 3.1 header fwrite("PKT", 3, 1, fileDump); // magic fwrite((WORD*)&pkt_version, 2, 1, fileDump); // major.minor version fwrite((BYTE*)&sniffer_id, 1, 1, fileDump); // sniffer id fwrite((WORD*)&wowInfo.build, 2, 1, fileDump); // client build fwrite(sessionKey, 1, 2, fileDump); // client build (aligned bytes) fwrite(hookInfo.locale, 4, 1, fileDump); // client lang fwrite(sessionKey, 40, 1, fileDump); // session key fwrite((DWORD*)&rawTime, 4, 1, fileDump); // started time fwrite((DWORD*)&tickCount, 4, 1, fileDump); // started tick's fwrite((DWORD*)&optionalHeaderLength, 4, 1, fileDump); // opional header length fflush(fileDump); } fwrite((DWORD*)&packetType, 4, 1, fileDump); // direction of the packet fwrite((DWORD*)&connectionId, 4, 1, fileDump); // connection id fwrite((DWORD*)&tickCount, 4, 1, fileDump); // timestamp of the packet fwrite((DWORD*)&optionalHeaderLength, 4, 1, fileDump); // optional data size fwrite((DWORD*)&size, 4, 1, fileDump); // size of the packet + opcode lenght fwrite((DWORD*)&opcode, 4, 1, fileDump); // opcode fwrite(buffer + opcodeSize, size - opcodeSize, 1, fileDump); // data #if _DEBUG printf("%s Opcode: 0x%04X Size: %-8u\n", packetType == CMSG ? "CMSG" : "SMSG", opcode, size); #endif fflush(fileDump); mtx.unlock(); }
// Console modification. void lConsole::ChangeOutputstream(void *NewStream) { ThreadSafe.lock(); this->StreamHandle = NewStream; ThreadSafe.unlock(); }
// 멀티스레드를 위한 imageRequset void imageRequset(string tempuri, int index) { int resp_leng; string request, response; char buffer[BUFFERSIZE]; struct sockaddr_in serveraddr; int sock = 0; WSADATA wsaData; vector<char> image; Uri *uri = new Uri; Uri resultURL = uri->Parse(tempuri); resultURL.Parse(tempuri); if (resultURL.getProtocol() == "http" || resultURL.getProtocol() == "") { hostent* hostname = gethostbyname(resultURL.getHost().c_str()); // Init WinSock WSADATA wsa_Data; int wsa_ReturnCode = WSAStartup(0x101, &wsa_Data); // Get the local hostname struct hostent *host_entry; host_entry = gethostbyname(resultURL.getHost().c_str()); char * ipaddress; ipaddress = inet_ntoa(*(struct in_addr *)*host_entry->h_addr_list); WSACleanup(); int port = 0; if (resultURL.getPort() == "") { port = 80; } else { port = atoi(resultURL.getPort().c_str()); } string path = resultURL.getPath(); if (resultURL.getHost() == "sang12456.cafe24.com") request = "GET " + path + " HTTP/1.1\r\n\r\n"; else request = "GET " + path + " HTTP/1.1\nHost: " + resultURL.getHost() + "\r\n\r\n";//"\nConnection : keep - alive\nCache - Control : max - age = 0\nAccept : text / html, application / xhtml + xml, application / xml; q = 0.9, image / webp, */*;q=0.8\nUpgrade-Insecure-Requests: 1\nUser-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36\nAccept-Encoding: gzip, deflate, sdch\nAccept-Language: ko-KR,ko;q=0.8,en-US;q=0.6,en;q=0.4\r\n\r\n"; //init winsock if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0) return; //open socket if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) return; //connect memset(&serveraddr, 0, sizeof(serveraddr)); serveraddr.sin_family = AF_INET; serveraddr.sin_addr.s_addr = inet_addr(ipaddress); serveraddr.sin_port = htons(port); if (connect(sock, (struct sockaddr *) &serveraddr, sizeof(serveraddr)) < 0) return; //send request if (send(sock, request.c_str(), request.length(), 0) != request.length()) return; //get response //cout << "response" << endl; response = ""; resp_leng = BUFFERSIZE; do { resp_leng = recv(sock, (char*)&buffer, BUFFERSIZE, 0); copy(buffer, buffer + resp_leng, back_inserter(image)); } while (resp_leng != 0); //disconnect closesocket(sock); //cleanup WSACleanup(); } else response = "not valid"; if (image[9] == '2' && image[10] == '0' && image[11] == '0') { int imageLen = image.size(); char *binary = new char[imageLen]; memset(binary, 0, imageLen); int j = 0; for (unsigned int k = 0; k < image.size(); k++) { binary[j] = image[k]; j++; } // 임계영역 mtx.lock(); char *temp; if ((temp = strstr(binary, "\n\n")) != NULL) { images.insert(pair<int, char*>(index, &temp[2])); imagecache.insert(pair<string, char*>(tempuri, &temp[2])); } else if ((temp = strstr(binary, "\r\n\r\n")) != NULL) { images.insert(pair<int, char*>(index, &temp[4])); imagecache.insert(pair<string, char*>(tempuri, &temp[4])); } imagecacheSize.insert(pair<string, int>(tempuri, image.size())); replace(ret, tempuri+"\"image", "image"); imageSize.insert(pair<int, int>(index, image.size())); mtx.unlock(); InvalidateRect(hwndMain, &rt, TRUE); } }
/** * \brief Test function * * Sets a message and send it over USB * Get the ACK sent back */ int main() { /* Opens the connection in non blocking mode */ #ifdef _WIN32 fd = open("COM7", O_RDWR | O_NOCTTY); #else fd = open("/dev/ttyACM0", O_RDWR | O_NOCTTY); #endif /* Check for error */ if (fd < 0) { fprintf(stderr, "[TEST FAILED]: Unable to open connection\n"); return EXIT_FAILURE; } /* Sets blocking mode */ #ifdef _WIN32 //To make blocking: unsigned long off = 0; if (ioctlsocket(fd, FIONBIO, &off) != 0) { /* Handle failure. */ } #else fcntl(fd, F_SETFL, 0); #endif /* clear the set */ FD_ZERO(&set); /* add our file descriptor to the set */ FD_SET(fd, &set); /* Defines ACK thread */ std::thread ack_thread(waitForACK); /* Creates a device shape */ DeviceShape ds(9, 9, 9); ds.on(4, 4, 4); /* Turns on one LED */ for (int i = 0; i < 9 ; i++) { ds.on(i,i,8-i); ds.on(i,i,i); ds.on(i,8-i,i); ds.on(8-i, i, i); } /* Creates a Request */ Request myRequest(1, 92, SET_LEDSTATS); /* Encodes data into the buffers created by the Request */ uint8_t *ledBuffer = new uint8_t [ds.getSizeInBytes()]; ds.toArray(ledBuffer); myRequest.encode(ledBuffer); /* Prints the message */ #if DEBUG std::cout << "My Request : " << myRequest.toStringDebug() << "\n"; #endif // uint8_t* reqLinear = new uint8_t[SIZE_REQUEST]; // reqLinear={0}; // /* Resets the connection */ // RequestMessage resetConnection(1, RESET); // resetConnection.encodeCrc(); // resetConnection.getListBuffer()[0].toArray(reqLinear); // #if DEBUG // std::cout << "Reset Connection : " << resetConnection.toStringDebug() << "\n"; // #endif /* Sents it over USB */ // write(fd, reqLinear, SIZE_REQUEST); // message_lock.lock(); // message_queue.push(buffLinear); // message_lock.unlock(); uint8_t* buffLinear = new uint8_t[SIZE_BUFFER](); /* Sends the Request */ for (int i = 0; i<myRequest.NbBuffers(); i++) { /* Prints */ #if DEBUG std::cout << "My Request buffer " << i << " : " << myRequest.getListBuffer()[i].toStringDebug(i) << "\n"; #endif /* Sends it over USB */ myRequest.getListBuffer()[i].toArray(buffLinear); #if DEBUG printBuffer("BUFFER ", buffLinear, SIZE_BUFFER); #endif /* Send it over USB */ if (write(fd, buffLinear, SIZE_BUFFER) == -1) std::cout << "error while sending buffer number " << i << " over USB \n"; message_lock.lock(); message_queue.push(buffLinear); message_lock.unlock(); } std::cout << "[TEST PASSED]\n"; ack_thread.detach(); close(fd); delete [] buffLinear; // delete [] reqLinear; delete [] ledBuffer; return 0; }
int callback(CSocket::connection &conn, char *recvbytes, size_t size, CServerSocket &sock) { //std::this_thread::sleep_for(std::chrono::seconds(1)); static const char okSignal[] = { "OK Signal" }; std::stringstream ss0; ss0.write(okSignal, sizeof(okSignal)); conn.send(ss0); std::stringstream ss/*(std::ios::binary | std::ios::in | std::ios::out)*/; conn.receive(ss, 0x7FFFF); dataStruct::dataStructT data2; cereal::PortableBinaryInputArchive input(ss); input(data2); std::time_t tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); std::string str = std::string(ctime(&tt)); str.pop_back(); std::replace(str.begin(), str.end(), ':', '_'); std::fstream file(str + ".txt", std::ios::out | std::ios::in | std::ios::binary | std::ios::trunc); //std::cout << "Arquivo => " << str + ".txt" << std::endl; cereal::JSONOutputArchive out(file); out(cereal::make_nvp("PC", data2)); conn.send(ss0); auto removeduplicates = [](std::deque<std::string> &deq) { //std::cout << deq.size() << std::endl; /*std::sort(deq.begin(), deq.end()); deq.erase(std::unique(deq.begin(), deq.end()), deq.end());*/ std::set<std::string> s; unsigned size = deq.size(); for (unsigned i = 0; i < size; ++i) s.insert(deq[i]); deq.assign(s.begin(), s.end()); //std::cout << deq.size() << std::endl; }; std::deque<std::string> sendToUser; for (auto &i : data2) { for (auto &asd : i.second) { if (asd.first.find("Hardware IDs") != std::string::npos) { svdrvsmutex.lock(); auto list = dvrs->getDriverPath(asd.second); svdrvsmutex.unlock(); if (list.size() == 0) continue; removeduplicates(list); sendToUser.insert(sendToUser.end(), list.begin(), list.end()); break; } } } auto sendFolder = [&](const std::string &path) { HANDLE hFind; WIN32_FIND_DATA data; auto pos = path.find_last_of('/'); std::string folder = (pos != std::string::npos)? std::string(&(path.c_str()[++pos])) : std::to_string(rand()); if (folder.size() == 0) { folder = std::to_string(rand()); } sendFoldersAndFiles f(1, folder); std::stringstream fstr(std::ios::binary | std::ios::in | std::ios::out); cereal::PortableBinaryOutputArchive output(fstr); output(f); hFind = FindFirstFile((path + "/*").c_str(), &data); if (hFind != INVALID_HANDLE_VALUE) { do { std::string cFileName = data.cFileName; std::string fullPath = path + std::string("/") + cFileName; if (cFileName != "." && cFileName != "..") { if ((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) { std::fstream fs(fullPath, std::ios::in | std::ios::binary); if (!fs.is_open()) { std::cout << "Falha ao abrir " << fullPath << std::endl; continue; } if(CServer::debug) std::cout << "header" << std::endl; conn.send(fstr); std::this_thread::sleep_for(std::chrono::milliseconds(10)); { std::stringstream okSign; conn.receive(okSign, 0x400); std::this_thread::sleep_for(std::chrono::milliseconds(10)); } if (CServer::debug) std::cout << cFileName << std::endl; std::atomic<int> signal = 0; std::atomic<bool> contnthr = true; std::thread sndthr(thrdsnd, std::ref(conn.tranfBytesSize), std::ref(conn), std::ref(contnthr), std::ref(signal)); conn.autoSendFile(cFileName, fs, tstsendfile, 1024 * 64, signal); std::this_thread::sleep_for(std::chrono::milliseconds(15)); contnthr = false; //std::this_thread::sleep_for(std::chrono::milliseconds(25)); if (sndthr.joinable()) { sndthr.join(); } } } } while (FindNextFile(hFind, &data)); FindClose(hFind); } }; removeduplicates(sendToUser); for (auto &l : sendToUser) { sendFolder(l); std::this_thread::sleep_for(std::chrono::milliseconds(100)); } { std::this_thread::sleep_for(std::chrono::milliseconds(100)); sendFoldersAndFiles f(1, "/"); std::stringstream ssendstr(std::ios::binary | std::ios::in | std::ios::out); cereal::PortableBinaryOutputArchive output(ssendstr); output(f); conn.send(ssendstr); std::this_thread::sleep_for(std::chrono::milliseconds(100)); } return 0; }
LRESULT CALLBACK WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) { HDC hdc; PAINTSTRUCT ps; int len = 0; hwndMain = hWnd; HBITMAP hBMP, hOldBmp; HPALETTE hPalette, hOldPalette; HDC hMemDC; BITMAP bm; HFONT font, oldfont; RECT rect; int width; int height; if (GetWindowRect(hWnd, &rect)) { rect.left = 10; rect.top = 45; width = rect.right - rect.left; height = rect.bottom - rect.top; } rt = rect; rect.top += 20; Gdiplus::GdiplusStartupInput gdiplusStartupInput; ULONG_PTR gdiplusToken; Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL); switch (iMessage) { case WM_CREATE: // edit control hEdit = CreateWindow("edit", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL, 250, 10, 300, 25, hWnd, (HMENU)NULL, g_hInst, NULL); origLVEditWndProc = (WNDPROC)SetWindowLong(hEdit, GWL_WNDPROC, (DWORD)LVEditWndProc); case WM_KEYDOWN: { switch (wParam) { case VK_PRIOR: scroll += 50; InvalidateRect(hwndMain, &rt, TRUE); break; case VK_NEXT: scroll -= 50; InvalidateRect(hwndMain, &rt, TRUE); break; } } case WM_PAINT: { int imageCount = 0; hdc = BeginPaint(hWnd, &ps); //FillRect(hdc, &rt, (HBRUSH)GetStockObject(WHITE_BRUSH)); rect.top += scroll; // dll에서 InvalidateRect를 통해서 WM_PAINT 메시지를 보낸다. // 이때 찾은 Path는 path.txt 파일에 기록되고 이를 읽어 Window에 보여준다. if (curState == FILESTATE) { // 임계영역 mtx1.lock(); ret.clear(); string line; ifstream myfile("path.txt"); if (myfile.is_open()) { while (getline(myfile, line)) { ret.push_back(line); } myfile.close(); } mtx1.unlock(); } // bmp local image load with double buffering if (LoadBitmapFromBMPFile("nexon.bmp", &hBMP, &hPalette, 0)) { GetObject(hBMP, sizeof(BITMAP), &bm); hMemDC = CreateCompatibleDC(hdc); hOldBmp = (HBITMAP)SelectObject(hMemDC, hBMP); hOldPalette = SelectPalette(hdc, hPalette, FALSE); RealizePalette(hdc); BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY); SelectObject(hMemDC, hOldBmp); DeleteObject(hBMP); SelectPalette(hdc, hOldPalette, FALSE); DeleteObject(hPalette); } Graphics graphics(hdc); Graphics memGraphics(hMemDC); for (unsigned int i = 0; i < ret.size(); i++) { // 텍스트 tag일 경우 if (ret[i] != "image") { int fontSize = 15; if (ret[i].substr(ret[i].length() - 2, 2) == "h1") { fontSize = 30; font = CreateFont(fontSize, 0, 0, 0, FW_ULTRABOLD, 0, 0, 0, HANGEUL_CHARSET, 0, 0, 0, 0, "돋움"); oldfont = (HFONT)SelectObject(hdc, font); DrawText(hdc, (ret[i].substr(0, ret[i].length() - 2)).c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); } else if (ret[i].substr(ret[i].length() - 2, 2) == "h2") { fontSize = 25; font = CreateFont(fontSize, 0, 0, 0, FW_BOLD, 0, 0, 0, HANGEUL_CHARSET, 0, 0, 0, 0, "돋움"); oldfont = (HFONT)SelectObject(hdc, font); DrawText(hdc, (ret[i].substr(0, ret[i].length() - 2)).c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); } else if (ret[i].substr(ret[i].length() - 2, 2) == "h3") { fontSize = 20; font = CreateFont(fontSize, 0, 0, 0, FW_BOLD, 0, 0, 0, HANGEUL_CHARSET, 0, 0, 0, 0, "돋움"); oldfont = (HFONT)SelectObject(hdc, font); DrawText(hdc, (ret[i].substr(0, ret[i].length() - 2)).c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); } else if (ret[i].substr(ret[i].length() - 2, 2) == "h4") { fontSize = 15; font = CreateFont(fontSize, 0, 0, 0, FW_BOLD, 0, 0, 0, HANGEUL_CHARSET, 0, 0, 0, 0, "돋움"); oldfont = (HFONT)SelectObject(hdc, font); DrawText(hdc, (ret[i].substr(0, ret[i].length() - 2)).c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); } else if (ret[i].substr(ret[i].length() - 2, 2) == "h5") { fontSize = 10; font = CreateFont(fontSize, 0, 0, 0, FW_BOLD, 0, 0, 0, HANGEUL_CHARSET, 0, 0, 0, 0, "돋움"); oldfont = (HFONT)SelectObject(hdc, font); DrawText(hdc, (ret[i].substr(0, ret[i].length() - 2)).c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); } else if (ret[i].substr(ret[i].length() - 2, 2) == "h6") { fontSize = 5; font = CreateFont(fontSize, 0, 0, 0, FW_BOLD, 0, 0, 0, HANGEUL_CHARSET, 0, 0, 0, 0, "돋움"); oldfont = (HFONT)SelectObject(hdc, font); DrawText(hdc, (ret[i].substr(0, ret[i].length() - 2)).c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); } else if (ret[i].substr(ret[i].length() - 5, 5) == "title") { fontSize = 35; font = CreateFont(fontSize, 0, 0, 0, FW_HEAVY, 0, 0, 0, HANGEUL_CHARSET, 0, 0, 0, 0, "돋움"); oldfont = (HFONT)SelectObject(hdc, font); DrawText(hdc, (ret[i].substr(0, ret[i].length() - 5)).c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); } else if (ret[i].substr(ret[i].length() - 9, 9) == "hyperText") { fontSize = 15; font = CreateFont(fontSize, 0, 0, 0, FW_BOLD, 0, 0, 0, HANGEUL_CHARSET, 0, 0, 0, 0, "돋움"); SetTextColor(hdc, RGB(0, 0, 255)); oldfont = (HFONT)SelectObject(hdc, font); DrawText(hdc, (ret[i].substr(0, ret[i].length() - 9)).c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); SetTextColor(hdc, RGB(0, 0, 0)); } else { if (ret[i].substr(ret[i].length() - 5, 5) == "image") { imageCount++; //continue; } fontSize = 15; font = CreateFont(fontSize, 0, 0, 0, 0, 0, 0, 0, HANGEUL_CHARSET, 0, 0, 0, 0, "돋움"); oldfont = (HFONT)SelectObject(hdc, font); if (ret[i].substr(ret[i].length() - 6, 6) == "center") { DrawText(hdc, (ret[i].substr(0, ret[i].length() - 6)).c_str(), -1, &rect, DT_CENTER | DT_WORDBREAK | DT_NOCLIP); } else if (ret[i].substr(ret[i].length() - 1, 1) == "p") { DrawText(hdc, (ret[i].substr(0, ret[i].length() - 2)).c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); } else { DrawText(hdc, ret[i].c_str(), -1, &rect, DT_LEFT | DT_WORDBREAK | DT_NOCLIP); } } SelectObject(hdc, oldfont); DeleteObject(font); rect.top += fontSize + 30; } else if (ret[i] == "image") { // image tag일 경우 unordered_map<int, int>::iterator FindImageSize = imageSize.find(imageCount); // 찾았다면 if (FindImageSize != imageSize.end()) { DWORD dwImageSize = FindImageSize->second; BYTE* pImageBuffer = NULL; unordered_map<int, char*>::iterator FindImage = images.find(imageCount); // 찾았다면 if (FindImage != images.end()) { pImageBuffer = (BYTE*)(FindImage->second); HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, dwImageSize); void* pData = GlobalLock(hGlobal); memcpy(pData, pImageBuffer, dwImageSize); GlobalUnlock(hGlobal); IStream* pStream = NULL; if (CreateStreamOnHGlobal(hGlobal, TRUE, &pStream) == S_OK) { //Image *pImage = Image::FromStream(pStream); shared_ptr<Image> pImage(Image::FromStream(pStream)); graphics.DrawImage(pImage.get(), rect.left, rect.top); rect.top += pImage->GetHeight(); } ::GlobalFree(hGlobal); } } imageCount++; } } maxHeight = rect.top; EndPaint(hWnd, &ps); return 0; } case WM_DESTROY: { PostQuitMessage(0); return 0; } } return DefWindowProc(hWnd, iMessage, wParam, lParam); }
bool client_func(const mg_connection& connection,enum mg_event event) { if(event==MG_AUTH) return true; if(event!=MG_REQUEST) return false; std::string method=connection.request_method; std::string request=connection.uri; std::string json_set_prefix="/json_set/"; std::string json_get_prefix="/json_get"; std::cout<<"Request: "<<request<<std::endl; try { if(msl::starts_with(request,json_set_prefix)) { std::cout<<" Set JSON "+method+" Request."<<std::endl; std::string json_set_str=request.substr(json_set_prefix.size(),request.size()-json_set_prefix.size()); if(method=="POST") json_set_str=std::string(connection.content,connection.content_len); std::cout<<json_set_str<<std::endl; msl::json json=msl::deserialize(json_set_str); std::cout<<" Parsing JSON Object:"<<std::endl; for(auto ii:json.getMemberNames()) { switch(json[ii].type()) { case Json::arrayValue: std::cout<<" Adding \""<<ii<<"\" as array."<<std::endl; break; case Json::objectValue: std::cout<<" Adding \""<<ii<<"\" as object."<<std::endl; break; case Json::nullValue: std::cout<<" Adding \""<<ii<<"\" as null."<<std::endl; break; case Json::intValue: std::cout<<" Adding \""<<ii<<"\" as int."<<std::endl; break; case Json::uintValue: std::cout<<" Adding \""<<ii<<"\" as uint."<<std::endl; break; case Json::realValue: std::cout<<" Adding \""<<ii<<"\" as real."<<std::endl; break; case Json::stringValue: std::cout<<" Adding \""<<ii<<"\" as string."<<std::endl; break; case Json::booleanValue: std::cout<<" Adding \""<<ii<<"\" as bool."<<std::endl; break; default: std::cout<<" Skipping \""<<ii<<"\" with invalid type."<<std::endl; continue; break; } database_lock.lock(); database[ii]=json[ii]; database_lock.unlock(); } msl::client_reply(connection,"","text/plain"); return true; } else if(msl::starts_with(request,json_get_prefix)) { std::cout<<" Get JSON "+method+" Request."<<std::endl; std::string json_get_str=request.substr(json_get_prefix.size(),request.size()-json_get_prefix.size()); if(method=="POST") json_get_str=std::string(connection.content,connection.content_len); std::vector<std::string> paths=get_paths(json_get_str); std::cout<<json_get_str<<std::endl; std::cout<<" Parsing JSON Path:"<<std::endl; database_lock.lock(); auto json_get_object=database; database_lock.unlock(); for(auto path:paths) { json_get_object=json_get_object[path]; switch(json_get_object.type()) { case Json::arrayValue: std::cout<<" Getting \""<<path<<"\" as array."<<std::endl; break; case Json::objectValue: std::cout<<" Getting \""<<path<<"\" as object."<<std::endl; break; case Json::nullValue: std::cout<<" Getting \""<<path<<"\" as null."<<std::endl; break; case Json::intValue: std::cout<<" Getting \""<<path<<"\" as int."<<std::endl; break; case Json::uintValue: std::cout<<" Getting \""<<path<<"\" as uint."<<std::endl; break; case Json::realValue: std::cout<<" Getting \""<<path<<"\" as real."<<std::endl; break; case Json::stringValue: std::cout<<" Getting \""<<path<<"\" as string."<<std::endl; break; case Json::booleanValue: std::cout<<" Getting \""<<path<<"\" as bool."<<std::endl; break; default: std::cout<<" Exiting \""<<path<<"\" with invalid type."<<std::endl; return false; } } msl::client_reply(connection,msl::serialize(json_get_object),"application/javascript"); return true; } } catch(std::exception& e) { std::cout<<" Error: "<<e.what()<<std::endl; } catch(...) { std::cout<<" Error: Unknown error occured."<<std::endl; } return false; }
void set(T _newvalue) { //mutex lock - not read and write at the same time mtx.lock(); value = _newvalue; mtx.unlock(); }
void STimer::Stop() { _mutex.lock(); _stop = true; _mutex.unlock(); }
void MemoryPool::clear() { locker_.lock(); for (auto &item : pool_) { delete[] reinterpret_cast<byte_type *>(item.second); } locker_.unlock(); }
static InitFunction initFunction([] () { g_hooksDLL->SetHookCallback(StringHash("loadsFrame"), [] (void*) { g_netLibrary->RunFrame(); /*g_loadScreenMutex.lock(); if (g_loadScreen.get()) { g_loadScreen->UpdateFrame(); } g_loadScreenMutex.unlock();*/ }); g_hooksDLL->SetHookCallback(StringHash("loadsClean"), [] (void*) { g_loadScreenMutex.lock(); if (g_loadScreen.GetRef()) { g_loadScreen = nullptr; } g_loadScreenMutex.unlock(); }); }); #endif #endif
// Will analyse every buffer from usrpT // each buffer has a size nDetect. nStorage is the size of the total transmission void detection(uint nDetect, int nStorage){ bool isDetected=false; int nCurrent=0; short *storage_short; storage_short=new short [nStorage]; short *p=0; float power; int i2=0,count_trans=0; std::vector<std::thread> processingV; int count=0; while(1){ std::this_thread::yield(); if (isDetected){ // Store the elements in storage_short if (nCurrent<nStorage){ // Fill storage_short i2=0; int conj_rx; while ((nCurrent<nStorage) && (i2<2*((int) nDetect))){ conj_rx=pow(-1,nCurrent); //DispVal(conj_rx); storage_short[nCurrent]=(p[i2])*conj_rx; nCurrent++; i2++; }; // Relase the just stored element std::this_thread::yield(); delete[] (usrpQ.front()); mtxUsrp.lock(); usrpQ.pop(); mtxUsrp.unlock(); std::this_thread::yield(); //Wait for a new element sem_wait(&usrpReady); p=usrpQ.front(); } else{ // End of transmission //count_trans=0; isDetected=false; nCurrent=0; processingV.push_back(std::thread(processing, storage_short, nStorage, count)); count++; storage_short=new short[nStorage]; } } else{ // Wait for new element sem_wait(&usrpReady); p=usrpQ.front(); // Test of detection power=powerTotArray(p, (int)2*nDetect); //if(power>50000)DispVal(power); count_trans++;//Avoid transient power amplification //Power threshold 60GHz=1000 if ( power>1000 && count_trans>10000 && count<1){ // If detection, keep the element std::cout<<"Detected Transmission\n"; //exit(1); isDetected=true; } else{ // Release the element std::this_thread::yield(); delete[] (usrpQ.front()); mtxUsrp.lock(); usrpQ.pop(); mtxUsrp.unlock(); std::this_thread::yield(); } } } for (auto& th : processingV) th.join(); }
int handle(int socket, const string& str, const User& user) { vector<string> tokens; string answer; string cmd; string arg_1; string arg_2; tokens = preProcess(str); switch(tokens.size()) { case 0: answer = INVALID_CMD_ERR; break; case 1: cmd = lower(tokens[0]); if(cmd == EXIT_CMD) answer = OK; if(cmd == HELP_CMD) answer = HELP; else answer = INVALID_CMD_ERR; break; case 2: cmd = lower(tokens[0]); arg_1 = tokens[1]; if(cmd == JOIN_GROUP_CMD) answer = OK; break; //number of args >= 3 default: cmd = lower(tokens[0]); arg_1 = tokens[1]; if(cmd == SEND_MSG_CMD) { string msg_content = join(tokens, " ", 2); Message msg(user.getName(), arg_1, msg_content); cout << "message: " << msg.getContent() << endl; chat_mtx.lock(); if(!chat.hasUser(msg.getSrcUserName())) answer = NO_SRC_USER_ERR; else if(!chat.hasUser(msg.getDstUserName())) answer = NO_DST_USER_ERR; else if(!chat.addMessage(msg)) answer = MSG_EXISTS_ERR; else answer = MSG_QUEUED; chat_mtx.unlock(); } else answer = INVALID_CMD_ERR; break; } if(send(socket, answer) < 0) error("send"); if(send(socket, "hur brbrb\n") < 0) error("send"); return 0; }
// Worker thread void HttpClient::networkThread() { HttpRequest *request = nullptr; auto scheduler = Director::getInstance()->getScheduler(); while (true) { if (s_need_quit) { break; } // step 1: send http request if the requestQueue isn't empty request = nullptr; s_requestQueueMutex.lock(); //Get request task from queue if (!s_requestQueue->empty()) { request = s_requestQueue->at(0); s_requestQueue->erase(0); } s_requestQueueMutex.unlock(); if (nullptr == request) { // Wait for http request tasks from main thread std::unique_lock<std::mutex> lk(s_SleepMutex); s_SleepCondition.wait(lk); continue; } // step 2: libcurl sync access // Create a HttpResponse object, the default setting is http access failed HttpResponse *response = new HttpResponse(request); processResponse(response, s_errorBuffer); // add response packet into queue s_responseQueueMutex.lock(); s_responseQueue->pushBack(response); s_responseQueueMutex.unlock(); if (nullptr != s_pHttpClient) { scheduler->performFunctionInCocosThread(CC_CALLBACK_0(HttpClient::dispatchResponseCallbacks, this)); } } // cleanup: if worker thread received quit signal, clean up un-completed request queue s_requestQueueMutex.lock(); s_requestQueue->clear(); s_requestQueueMutex.unlock(); if (s_requestQueue != nullptr) { delete s_requestQueue; s_requestQueue = nullptr; delete s_responseQueue; s_responseQueue = nullptr; } }
int KiekkoNetwork::InitializeNetwork() { if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) { printf("WSAStartup(...) failed! Error code : %d\n", WSAGetLastError()); return 1; } struct addrinfo hints; ZeroMemory(&hints, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; hints.ai_flags = AI_PASSIVE; struct addrinfo *result = NULL; if (getaddrinfo(SERVER.c_str(), PORT, &hints, &result) != 0) { printf("getaddrinfo(...) failed! Error code: %d\n", WSAGetLastError()); WSACleanup(); return 1; } struct addrinfo* ptr = NULL; for (ptr = result; ptr != NULL; ptr=ptr->ai_next) { ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol); if (ConnectSocket == INVALID_SOCKET) { printf("socket(...) failed! Error code : %d\n", WSAGetLastError()); WSACleanup(); return 1; } if (connect(ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen) == SOCKET_ERROR) { printf("connect(...) failed! Error code : %d\n", WSAGetLastError()); closesocket(ConnectSocket); ConnectSocket = INVALID_SOCKET; continue; } else printf("Connect success!\n", WSAGetLastError()); break; } freeaddrinfo(result); if (ConnectSocket == INVALID_SOCKET) { printf("Unable to connect to server!\n"); WSACleanup(); return 1; } recvThreadMutex.lock(); std::thread th(ReceiveThread, ConnectSocket, recvLength); th.detach(); SendPackage temp; temp.ownPos = 125.0; if (SendMsg(temp)) return 1; return 0; }
void lConsole::ToggleScrollbackPrinting() { ThreadSafe.lock(); this->ShouldPrintScrollback = !this->ShouldPrintScrollback; ThreadSafe.unlock(); }
// Worker thread void HttpClient::networkThread() { HttpRequest *request = nullptr; auto scheduler = Director::getInstance()->getScheduler(); while (true) { if (s_need_quit) { break; } // step 1: send http request if the requestQueue isn't empty request = nullptr; s_requestQueueMutex.lock(); //Get request task from queue if (!s_requestQueue->empty()) { request = s_requestQueue->at(0); s_requestQueue->erase(0); } s_requestQueueMutex.unlock(); if (nullptr == request) { // Wait for http request tasks from main thread std::unique_lock<std::mutex> lk(s_SleepMutex); s_SleepCondition.wait(lk); continue; } // step 2: libcurl sync access // Create a HttpResponse object, the default setting is http access failed HttpResponse *response = new HttpResponse(request); // request's refcount = 2 here, it's retained by HttpRespose constructor request->release(); // ok, refcount = 1 now, only HttpResponse hold it. long responseCode = -1; int retValue = 0; // Process the request -> get response packet switch (request->getRequestType()) { case HttpRequest::Type::GET: // HTTP GET retValue = processGetTask(request, writeData, response->getResponseData(), &responseCode, writeHeaderData, response->getResponseHeader()); break; case HttpRequest::Type::POST: // HTTP POST retValue = processPostTask(request, writeData, response->getResponseData(), &responseCode, writeHeaderData, response->getResponseHeader()); break; case HttpRequest::Type::PUT: retValue = processPutTask(request, writeData, response->getResponseData(), &responseCode, writeHeaderData, response->getResponseHeader()); break; case HttpRequest::Type::DELETE: retValue = processDeleteTask(request, writeData, response->getResponseData(), &responseCode, writeHeaderData, response->getResponseHeader()); break; default: CCASSERT(true, "CCHttpClient: unkown request type, only GET and POSt are supported"); break; } // write data to HttpResponse response->setResponseCode(responseCode); if (retValue != 0) { response->setSucceed(false); response->setErrorBuffer(s_errorBuffer); } else { response->setSucceed(true); } // add response packet into queue s_responseQueueMutex.lock(); s_responseQueue->pushBack(response); s_responseQueueMutex.unlock(); if (nullptr != s_pHttpClient) { scheduler->performFunctionInCocosThread(CC_CALLBACK_0(HttpClient::dispatchResponseCallbacks, this)); } } // cleanup: if worker thread received quit signal, clean up un-completed request queue s_requestQueueMutex.lock(); s_requestQueue->clear(); s_requestQueueMutex.unlock(); if (s_requestQueue != nullptr) { delete s_requestQueue; s_requestQueue = nullptr; delete s_responseQueue; s_responseQueue = nullptr; } }
GameHost_Private* start_game_host(uint32_t ageMcpId) { PGconn* postgres = PQconnectdb(DS::String::Format( "host='%s' port='%s' user='******' password='******' dbname='%s'", DS::Settings::DbHostname(), DS::Settings::DbPort(), DS::Settings::DbUsername(), DS::Settings::DbPassword(), DS::Settings::DbDbaseName()).c_str()); if (PQstatus(postgres) != CONNECTION_OK) { fprintf(stderr, "Error connecting to postgres: %s", PQerrorMessage(postgres)); PQfinish(postgres); return 0; } PostgresStrings<1> parms; parms.set(0, ageMcpId); PGresult* result = PQexecParams(postgres, "SELECT \"AgeUuid\", \"AgeFilename\", \"AgeIdx\", \"SdlIdx\", \"Temporary\"" " FROM game.\"Servers\" WHERE idx=$1", 1, 0, parms.m_values, 0, 0, 0); if (PQresultStatus(result) != PGRES_TUPLES_OK) { fprintf(stderr, "%s:%d:\n Postgres SELECT error: %s\n", __FILE__, __LINE__, PQerrorMessage(postgres)); PQclear(result); PQfinish(postgres); return 0; } if (PQntuples(result) == 0) { fprintf(stderr, "[Game] Age MCP %u not found\n", ageMcpId); PQclear(result); PQfinish(postgres); return 0; } else { DS_DASSERT(PQntuples(result) == 1); GameHost_Private* host = new GameHost_Private(); host->m_instanceId = PQgetvalue(result, 0, 0); host->m_ageFilename = PQgetvalue(result, 0, 1); host->m_ageIdx = strtoul(PQgetvalue(result, 0, 2), 0, 10); host->m_gameMaster = 0; host->m_serverIdx = ageMcpId; host->m_postgres = postgres; host->m_temp = strcmp("t", PQgetvalue(result, 0, 4)) == 0; // Fetch the age states Auth_FetchSDL sdlFetch; AuthClient_Private fakeClient; sdlFetch.m_client = &fakeClient; sdlFetch.m_ageFilename = host->m_ageFilename; sdlFetch.m_sdlNodeId = strtoul(PQgetvalue(result, 0, 3), 0, 10); PQclear(result); s_authChannel.putMessage(e_AuthFetchSDL, reinterpret_cast<void*>(&sdlFetch)); DS::FifoMessage reply = fakeClient.m_channel.getMessage(); if (reply.m_messageType != DS::e_NetSuccess) { fputs("[Game] Error fetching Age SDL\n", stderr); PQfinish(postgres); delete host; return 0; } host->m_sdlIdx = sdlFetch.m_sdlNodeId; host->m_globalState = sdlFetch.m_globalState; // Load the local state and see if it needs to be updated try { host->m_localState = SDL::State::FromBlob(sdlFetch.m_localState); } catch (DS::EofException&) { fprintf(stderr, "[SDL] Error parsing Age SDL state for %s\n", host->m_ageFilename.c_str()); PQfinish(postgres); delete host; return 0; } if (host->m_localState.update()) { DS::Blob local = host->m_localState.toBlob(); dm_local_sdl_update(host, local); host->m_ageSdlHook = SDL::State::FromBlob(local); } else { host->m_ageSdlHook = SDL::State::FromBlob(sdlFetch.m_localState); } host->m_ageSdlHook.merge(host->m_globalState); s_gameHostMutex.lock(); s_gameHosts[ageMcpId] = host; s_gameHostMutex.unlock(); // Fetch initial server state PostgresStrings<1> parms; parms.set(0, host->m_serverIdx); PGresult* result = PQexecParams(host->m_postgres, "SELECT \"Descriptor\", \"ObjectKey\", \"SdlBlob\"" " FROM game.\"AgeStates\" WHERE \"ServerIdx\"=$1", 1, 0, parms.m_values, 0, 0, 0); if (PQresultStatus(result) != PGRES_TUPLES_OK) { fprintf(stderr, "%s:%d:\n Postgres SELECT error: %s\n", __FILE__, __LINE__, PQerrorMessage(host->m_postgres)); } else { int count = PQntuples(result); for (int i=0; i<count; ++i) { DS::BlobStream bsObject(DS::Base64Decode(PQgetvalue(result, i, 1))); DS::Blob sdlblob = DS::Base64Decode(PQgetvalue(result, i, 2)); MOUL::Uoid key; key.read(&bsObject); try { SDL::State state = SDL::State::FromBlob(sdlblob); state.update(); GameState gs; gs.m_isAvatar = false; gs.m_persist = true; gs.m_state = state; host->m_states[key][PQgetvalue(result, i, 0)] = gs; } catch (DS::EofException) { fprintf(stderr, "[SDL] Error parsing state %s for [%04X]%s\n", PQgetvalue(result, i, 0), key.m_type, key.m_name.c_str()); } } } PQclear(result); std::thread threadh(&dm_gameHost, host); threadh.detach(); return host; } }
void threadfunction_mutex_lock(int arg) { coutLock.lock(); cout << "mutex lock: " << arg << ", this_thread::get_id=" << this_thread::get_id() << "\n"; coutLock.unlock(); }
void QueryWorld::updateCopyWorld(const World& world) { m_copyWorldLock.lock(); m_copyWorld = world; m_copyWorldLock.unlock(); }
void AddActiveSocket(int *s, int id) { socketlistmtx.lock(); purkka->activeSocket[id] = s; socketlistmtx.unlock(); }
void zcm_debug_lock(void) { mut.lock(); }
void dijkstra_pq_thread(CSRGraph *g, int *dist, std::priority_queue<Priority_struct, std::vector<Priority_struct>, Compare_priority> &pq, int threadNum, std::mutex *dist_locks) { while(!pq.empty()) { queue_lock.lock(); if(pq.empty()) { queue_lock.unlock(); break; } Priority_struct temp_struct = pq.top(); int u = temp_struct.node_name; pq.pop(); printf("Popped\n"); for(int i=0; i< pq.size();i++){ printf(" %d", pq[i]); } printf("\n"); int udist = dist[u]; queue_lock.unlock(); std::vector<int> neighbors = CSRGraph_getNeighbors(g, u); int neighbor; for(neighbor=0;neighbor < neighbors.size(); neighbor++) { int v = neighbors[neighbor]; int uvdist = CSRGraph_getDistance(g, u, v); int alt = udist + uvdist; dist_locks[v].lock(); if(alt < dist[v]) { dist[v] = alt; dist_locks[v].unlock(); Priority_struct temp2; temp2.node_name=v; temp2.node_weight = uvdist; queue_lock.lock(); pq.push(temp2); printf("Pushed\n"); for(int i=0; i< pq.size();i++){ printf(" %d", pq[i]); } printf("\n"); queue_lock.unlock(); } else { dist_locks[v].unlock(); } } } //printf("Thread %d ended.\n", threadNum); }
void lockmap(){ mu.lock(); }
void storeDataX(uhd::rx_streamer::sptr rx_stream, uhd::usrp::multi_usrp::sptr dev, size_t buffer_size, uint nDetect){ // Create storage for a single buffer from USRP short *buff_short; buff_short=new short[2*buffer_size]; short *storage_short; storage_short=new short [2*nDetect]; uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); std::cout << "Stop the transmitter by pressing ctrl-c \n"; stream_cmd.num_samps = buffer_size; stream_cmd.stream_now = true; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; dev->issue_stream_cmd(stream_cmd); uhd::rx_metadata_t md; size_t n_rx_samps=0; int n_rx_last; while (1){ n_rx_samps=0; // Fill the storage buffer loop while (n_rx_samps<nDetect){ n_rx_last=0; // Fill buff_short while (n_rx_last==0) { n_rx_last=rx_stream->recv(&buff_short[0], buffer_size, md, 3.0); //std::this_thread::yield(); }; sec_count++; // Check if no overflow if (n_rx_last!=(int)buffer_size) { std::cerr << "I expect the buffer size to be always the same!\n"; std::cout<<"Read only:"<<n_rx_last<<"\n"; std::cout<<"Buffer:"<<buffer_size<<"\n"; exit(1); }; // Fill storage int i1=2*n_rx_samps; int i2=0; while ((i1<(int) (2*nDetect)) && (i2<2*((int) buffer_size))){ storage_short[i1]=buff_short[i2]; i1++; i2++; }; //storage_short=buff_short; n_rx_samps=n_rx_samps+n_rx_last; //std::cout << "n_rx_samps=" << n_rx_samps << std::endl; }//storage_short now full mtxQ.lock(); bufferQ.push(buff_short); mtxQ.unlock(); //delete buff_short; buff_short=new short [2*buffer_size]; // Change memory cell used //usleep(1000000/4); sem_post( &isReady); // Gives the start to detection part }//end while 1 }