HBITMAP CSIM_ext::createBitmap(string &info)
{
BITMAPINFO *bmp = (BITMAPINFO*)unpackData(getToken(info, '\n').c_str());
void *bits = unpackData(getToken(info, '\n').c_str());
HDC hDC = CreateCompatibleDC(NULL);
HBITMAP hRes = CreateBitmap(bmp->bmiHeader.biWidth, bmp->bmiHeader.biHeight, bmp->bmiHeader.biPlanes, bmp->bmiHeader.biBitCount, NULL);
SetDIBits(hDC, hRes, 0, bmp->bmiHeader.biHeight, bits, bmp, DIB_RGB_COLORS);
DeleteDC(hDC);
free(bmp);
free(bits);
return hRes;
}
int Log::deserialize(void const * const data)
{
#ifdef DEBUG_OUT
printf("Log::deserialize(void const * const data)\n");
#endif //DEBUG_OUT
const MEMUNIT* data2 = (MEMUNIT*)data;
unpackNData(data2, this->log, LOG_MESSAGE_SIZE);
unpackNData(data2, this->sourceID, ID_SIZE);
unpackNData(data2, this->uniqueSourceID, UNIQUEID_SIZE);
unpackData(data2, this->level);
unpackData(data2, this->logtime);
return this->getSerializedSize();
}
bool CCTextureASTC::initWithContentsOfFileAsync(const char* path)
{
int len = 0;
std::string lowerCase(path);
if (lowerCase.find(".ccz") != std::string::npos)
{
len = ZipUtils::ccInflateCCZFile(path, &m_data);
}
else if (lowerCase.find(".gz") != std::string::npos)
{
len = ZipUtils::ccInflateGZipFile(path, &m_data);
}
else
{
m_data = CCFileUtils::sharedFileUtils()->getFileData(path, "rb", (unsigned long *)(&len));
}
if(len<0){
deleteData();
this->release();
return false;
}
m_uName = 0;
m_uWidth = m_uHeight = 0;
if (!unpackData(m_data))
{
deleteData();
this->release();
return false;
}
/* Keep our GL texture name alive, even after we're destroyed. */
setRetainName(true);
return true;
}
bool CCTextureASTC::initWithContentsOfFile(const char* path)
{
int len = 0;
std::string lowerCase(path);
if (lowerCase.find(".ccz") != std::string::npos)
{
len = ZipUtils::ccInflateCCZFile(path, &m_data);
}
else if (lowerCase.find(".gz") != std::string::npos)
{
len = ZipUtils::ccInflateGZipFile(path, &m_data);
}
else
{
m_data = CCFileUtils::sharedFileUtils()->getFileData(path, "rb", (unsigned long *)(&len));
}
if(len<0){
this->release();
return false;
}
m_uName = 0;
m_uWidth = m_uHeight = 0;
if (!unpackData(m_data) ||!createGLTexture())
{
this->release();
return false;
}
return true;
}
int Telegram::deserialize(void const * const data)
{
const MEMUNIT* data2 = (MEMUNIT*)data;
#ifdef DEBUG_OUT
printf("in Telegram::deserialize(void const * const data)\n");
#endif //DEBUG_OUT
unpackNData(data2, this->destinationID, UNIQUEID_SIZE);
unpackNData(data2, this->sourceID, UNIQUEID_SIZE);
unpackData(data2, this->type);
//unpackData(data2, this->telegramSize);
unpackData(data2, this->uniqueDestination);
#ifdef DEBUG_OUT
printf("Offset data2 %p to data %p\n", data2, data);
#endif //DEBUG_OUT
return Telegram::getSerializedSize();
}
int main(int argc, char *argv[])
{
int sockfd;
int serverPort;
int new_fd;
struct sockaddr_in serv_addr, cli_addr;
int clilen;
printf("TCP server example\n\n");
if (argc != 2) {
fprintf(stderr,"Usage: tcpServe serverPort \n");
exit(1);
}
serverPort = atoi(argv[1]);
printf("port = %i\n", serverPort);
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(serverPort);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(bind(sockfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) < 0)
{
printf("could not bind\n");
}
listen(sockfd, 10);
clilen = sizeof cli_addr;
while(1) {
new_fd = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen);
unsigned char buffer[4];
int size = read(new_fd, buffer, 4);
if(size > 0) {
unsigned int a,b;
printf("received: %x %x %x %x\n", buffer[0],buffer[1],buffer[2],buffer[3]);
unpackData(buffer, &a, &b);
printf("ggt of %i %i is %i\n", a ,b, ggt(a,b));
}
}
close(sockfd);
return 0;
}
//Get element from Hashtable
int get(int key, int* error){
//Build buffer and initialize it
unsigned char buffer[BUFSIZE];
packData(buffer,"GET",key,0);
//Send that data to server
sendMessage(buffer);
//Receive awnser
receiveMessage(buffer);
//Unpack data
char command[4];
int a,b;
unpackData(buffer,command,&a,&b);
//Check if problem rann correctly
*error = buffer[0] == 'V';
//Return if methof ran successful
return b;
}
int main(int argc, char *argv[]) {
struct sockaddr_in their_addr; // connector's address information
struct sockaddr_in my_addr; // local address information
struct hostent *he;
int numbytes;
int serverPort;
unsigned int a = 0;
unsigned int b = 0;
unsigned int testa = 0;
unsigned int testb = 0;
int socketfd = 0;
int sendRepeatTimes = 50;
unsigned char buffer[4];
printf("TCP client\n\n");
if (argc != 5) {
fprintf(stderr, "Usage: tcpClient serverName serverPort int1 int2\n");
exit(1);
}
serverPort = atoi(argv[2]);
a = (unsigned int) atoi(argv[3]);
b = (unsigned int) atoi(argv[4]);
//Resolv hostname to IP Address
if ((he = gethostbyname(argv[1])) == NULL ) { // get the host info
herror("gethostbyname");
exit(1);
}
printf("Arguments server=%s:%i NrA=%i NrB=%i\n", argv[1], serverPort, a, b);
// create server socket
socketfd = socket(PF_INET, SOCK_STREAM, 0);
if (socketfd == -1) {
fprintf(stderr, "Create Socket: Error %i\n", errno);
} else {
//setup transport address
puts("Create socket!\n");
their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(serverPort);
their_addr.sin_addr = *((struct in_addr *) he->h_addr);
memset(their_addr.sin_zero, '\0', sizeof their_addr.sin_zero);
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(LOCAL_PORT);
my_addr.sin_addr.s_addr = INADDR_ANY;
memset(my_addr.sin_zero, '\0', sizeof my_addr.sin_zero);
// bind socket to local machine
int yes = 1;
// reuse socket if already in used
if (setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int))
== -1) {
perror("setsockopt");
exit(1);
}
if (bind(socketfd, (struct sockaddr *) &my_addr, sizeof my_addr)
== -1) {
fprintf(stderr, "Bind socket: Error %i\n", errno);
} else {
puts("Bind socket!\n");
packData(&buffer, a, b);
unpackData(&buffer, &testa, &testb);
if (testa != a || testb != b) {
fprintf(stderr, "Pack Data: wrong implementation \n");
} else {
puts("Pack data!\n");
}
if (connect(socketfd, (struct sockaddr *) &their_addr,
sizeof their_addr) == -1) {
fprintf(stderr, "connect to server: Error %i\n", errno);
} else {
puts("connected to server!\n");
while (sendRepeatTimes--) {
numbytes = send(socketfd, buffer, sizeof buffer, 0);
if (numbytes == -1) {
fprintf(stderr, "send: Error %i\n", errno);
}
printf("send %i Bytes\n",numbytes);
}
}
close(socketfd);
puts("close socket!\n");
puts("tcpClient End\n\n");
}
}
return 0;
}
int main(int argc, char *argv[]) {
struct sockaddr_storage their_addr;
socklen_t addr_size;
int sockfd;
struct addrinfo hints, *res;
unsigned char buffer[4];
unsigned int a=0;
unsigned int b=0;
int ergebnis;
printf("TCP/UDP server for TechGI 4\n\n");
if (argc != 2) {
fprintf(stderr,"Usage: server udport \n");
exit(1);
}
// get serverport
const char* udpPort =argv[1];
//load address
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_PASSIVE;
getaddrinfo(NULL, udpPort, &hints, &res);
printf("udpPort: %s\n",udpPort);
//create socket
sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
//bind socket
bind(sockfd, res->ai_addr, res->ai_addrlen);
addr_size = sizeof their_addr;
//recieve packet and test
int recieve = recvfrom(sockfd, &buffer, 20, 0, (struct sockaddr *)&their_addr, &addr_size);
printf("Recieved %d Byte\n", recieve);
//unpack buffer
unpackData(buffer, &a, &b);
//calculate result and return
ergebnis = ggt(a, b);
printf("Zahl 1: %d Zahl 2: %d GGT: %d \n", a, b, ergebnis);
}
// ------------ MAIN --------------
int main(int argc, char *argv[])
{
// usage check / notification
if(argc != 6) {
printf("usage Error: use: hashServer serverAddress serverPort offset[0,64,128,196] successorAddress successorPort\n\n");
exit(1);
}
// offset
offset = atoi(argv[3]);
// alloc hashtable
table = (struct hashnode *) malloc(sizeof(struct hashnode) * 64);
// set up successor
successor_port = atoi(argv[5]);
if ((successor_he = gethostbyname(argv[4])) == NULL) { // get the host info
herror("gethostbyname");
exit(1);
}
successor_their_addr.sin_family = AF_INET;
successor_their_addr.sin_port = htons(successor_port);
successor_their_addr.sin_addr = *((struct in_addr *)successor_he->h_addr);
memset(successor_their_addr.sin_zero, '\0', sizeof successor_their_addr.sin_zero);
successor_addrlen = sizeof(successor_their_addr);
//set up local port
int sockfd, status;
struct sockaddr_in myaddr; // local address information
unsigned char buffer[INTERNAL_BUFFER_LENGTH]; // assume longest
unsigned int key, value;
char command[4];
// alloc open request table
// struct client_request *openClientRequests;
// openClientRequests = (struct client_request *) malloc(sizeof(struct client_request) * 10); // max. ten parallel connections
// ---------- UDP --------
// setup UDP address
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = INADDR_ANY;
myaddr.sin_port = htons(atoi(argv[2])); // UDP
// init udp sock
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(bind(sockfd, (struct sockaddr *)&myaddr, sizeof(myaddr)) < 0){
printf("FATAL: UDP binding error\n");
}
if ((server_he = gethostbyname(argv[1])) == NULL) { // get the host info
herror("gethostbyname");
exit(1);
}
server_addr.sin_addr = *((struct in_addr *)successor_he->h_addr);
server_ip = server_addr.sin_addr.s_addr;
server_port = atoi(argv[2]);
printf("Post-poning finger-table setup...\n");
// wait for nodes to load
sleep(5);
printf("Setup finger-tables:\n");
// pack getAddress data
strcpy(command, "xad");
forceForwardQuery(command, 2, 0, server_ip, server_port);
printf("Complete.\n\n");
// ------- CORE LOOP -----------
while(1) {
struct sockaddr_storage their_addr;
socklen_t addr_size;
printf("Waiting ...\n");
addr_size = sizeof(their_addr);
status = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&their_addr, &addr_size);
printf("Recieved query.\n");
if(status <= 0) {
printf("Error: receiving");
} else {
if (isInternalCommunication(buffer)) {
unsigned long responseAddress;
unsigned int responsePort;
unpackDataFromInternal(buffer, command, &key, &value, &responseAddress, &responsePort);
printf("INTERNAL: [%s] %d:%d (origin: %lu:%d)\n", command, key, value, responseAddress, responsePort);
if (isActiveQuery(command) && canHandleQueryLocally(key)) {
printf("HANDLE...\n");
handleQuery(command, key, value, responseAddress, responsePort);
} else if(isAddressQuery(command)){
handleAddressQuery(command, key, value, responseAddress, responsePort);
} else {
printf("PASS...\n");
forwardQuery(command, key, value, responseAddress, responsePort);
}
} else {
unpackData(buffer, command, &key, &value);
printf("CLIENT: [%s] %d:%d \n", command, key, value);
int requestId = nextFreeRequestId(openClientRequests);
struct client_request request;
request.socket = *((struct sockaddr *)&their_addr);
request.socket_addr_len = sizeof(their_addr);
request.active = 1;
request.key = key;
struct sockaddr_in clientInAddress;
clientInAddress = *((struct sockaddr_in *) &their_addr);
request.clientAddress = clientInAddress.sin_addr.s_addr;
request.clientPort = clientInAddress.sin_port; //todo
openClientRequests[requestId] = request;
if (canHandleQueryLocally(key)) {
printf("HANDLE...\n");
handleQuery(command, key, value, request.clientAddress, request.clientPort);
} else {
printf("FORCE-FORWARD...\n");
forceForwardQuery(command, key, value, request.clientAddress, request.clientPort);
printf("Query entered cluster.\n");
}
}
}
}
close(sockfd);
return 0;
}
void unpackDataFromInternal(unsigned char *buffer, char *command, unsigned int *key, unsigned int *value, unsigned long *responseAddress, unsigned int *responsePort) {
*responsePort = (buffer[12] << 8) | buffer[13];
*responseAddress = (long) 0;
*responseAddress = (((buffer[8] << 24) | (buffer[9] << 16)) | buffer[10] << 8) | buffer[11];
unpackData(buffer, command, key, value);
}
int rpcCall(int cmd, int k, int v)
{
int sockfd;
if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
printf("Fatal: Socket not created!");
return 0;
}
// translate cmd id to cmd string
if(cmd == 0) strcpy(commandName, "set");
if(cmd == 1) strcpy(commandName, "get");
if(cmd == 2) strcpy(commandName, "del");
packData(buffer, commandName, k, v);
printf("\nSending: %s %d %d\n", commandName, k, v);
if(sendto(sockfd, buffer, sizeof(buffer), 0, (const struct sockaddr *)&their_addr, addrlen) < 0){
printf("Fatal: Sending error.\n");
return 0;
}
printf("Send complete. Waiting for response...\n");
status = 0;
while(status == 0) {
status = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&their_addr, &addrlen);
}
// mega hardcode hack because their_addr is modified in recvfrom
their_addr.sin_port = server_port;
unpackData(buffer, commandName_recv, &key_recv, &value_recv);
printf("Received: %s %d %d \n", commandName_recv, key_recv, value_recv);
close(sockfd);
if(cmd == SET_COMMAND){
if(isOkQuery(commandName_recv)){
return 1;
} else{
return ERROR;
}
} else if(cmd == GET_COMMAND) {
if(isValueQuery(commandName_recv)){
return value_recv;
} else if (isNotFoundQuery(commandName_recv)) {
return NOT_FOUND;
} else{
return ERROR;
}
} else if(cmd == DELETE_COMMAND) {
if (isOkQuery(commandName_recv)) {
return 0;
} else if (isNotFoundQuery(commandName_recv)) {
return NOT_FOUND;
} else {
return ERROR;
}
}
}
int main(int argc, char *argv[]) {
int sockfd;
struct sockaddr_in own_addr, client_addr; // connector's address information
struct hostent *he;
int udpPort;
struct timespec t2, t3;
printf("Server starts \n");
if (argc != 2) {
fprintf(stderr,"Usage: udpPort\n");
exit(1);
}
printf("server port reading\n");
//Port setzen
udpPort = atoi(argv[1]); //atoi holt aus einem String eine Zahl
printf("server port is readed\n");
printf("server create a socket\n");
//set a udp Server
sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
if(sockfd == -1) {
fprintf(stderr, "Error creating socket DAS HIER????\n");
return 1;
}
printf("Server socked created\n");
//Resolv hostname to IP Address
if ((he=gethostbyname("localhost")) == NULL) { // get the host info
herror("gethostbyname");
printf("servername couldn't set");
exit(1);
}
printf("Servername localhost is set");
own_addr.sin_family = AF_INET;
own_addr.sin_port = htons(udpPort);
own_addr.sin_addr = *((struct in_addr *)he->h_addr);
memset(own_addr.sin_zero, '\0', sizeof own_addr.sin_zero);
//bind socket
if(bind(sockfd, (const struct sockaddr*)&own_addr, sizeof(own_addr)) == -1) {
fprintf(stderr, "Error creating socket\n");
return 1;
}
socklen_t client_addr_size;
char buffer[20];
int n;
while(1) {
printf("server ist waiting for Request");
if((n=recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&client_addr, &client_addr_size)) != 20) {
fprintf(stderr, "Server :::Error receiving data. expected 20 bytes but got %d \n", n);
return 1;
}
//Zweiter Zeitstempel
clock_gettime(CLOCK_REALTIME, &t2);
printf("Request received");
if(!checkMessage(buffer)) {
fprintf(stderr, "bad message received");
return 1;
}
if(unpackData(buffer)==false){
printf("Error, unknown command");
}
//Dritter Zeitstempel
//don't print but send
//define command
packData(buffer, &t2);
if((n=sendto(sockfd, buffer, 20, 0, (struct sockaddr*)&client_addr, client_addr_size)) != 20) {
fprintf(stderr, "Error sending back data. expected 20 bytes but got %d \n", n);
return 1;
}
clock_gettime(CLOCK_REALTIME, &t3);
packData2(buffer, &t2,&t3);
if((n=sendto(sockfd, buffer, 20, 0, (struct sockaddr*)&client_addr, client_addr_size)) != 20) {
fprintf(stderr, "Error sending back data. expected 20 bytes but got %d \n", n);
return 1;
}
}
if( close(sockfd) == -1 ) {
fprintf(stderr, "Error closing socket.\n");
}
return 0;
}
