243 lines
6.6 KiB
C++
243 lines
6.6 KiB
C++
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <unistd.h>
|
|
#include <assert.h>
|
|
#include <thread>
|
|
|
|
int Nx, Ny;
|
|
uint8_t *buf;
|
|
|
|
void SetPixel(int x, int y, uint8_t r, uint8_t g, uint8_t b){
|
|
if (x < 0 || x >= Nx || y < 0 || y >= Ny) return;
|
|
buf[3*(x+Nx*y)+0] = r;
|
|
buf[3*(x+Nx*y)+1] = g;
|
|
buf[3*(x+Nx*y)+2] = b;
|
|
}
|
|
|
|
void SetPixel(int x, int y, uint32_t c){
|
|
SetPixel(x, y, (c >> 16)&0xff, (c >> 8)&0xff, c&0xff);
|
|
}
|
|
|
|
uint32_t GetPixel(int x, int y){
|
|
if (x < 0 || x >= Nx || y < 0 || y >= Ny) return 0;
|
|
uint32_t r = buf[3*(x+Nx*y)+0];
|
|
uint32_t g = buf[3*(x+Nx*y)+1];
|
|
uint32_t b = buf[3*(x+Nx*y)+2];
|
|
return (r << 16) | (g << 8) | b;
|
|
}
|
|
|
|
|
|
static const int PFT_CONNECTION_TIMEOUT = 1;
|
|
volatile int PFT_ClientThreadCount = 0;
|
|
|
|
bool PFT_ReadIdent(char** begin, char* end, char* out, int size){
|
|
int i = 0;
|
|
while (*begin != end && isalpha(**begin) && i < size-1){
|
|
out[i++] = **begin;
|
|
(*begin)++;
|
|
}
|
|
out[i] = '\0';
|
|
return i != 0;
|
|
}
|
|
|
|
bool PRF_ReadInt(char** begin, char* end, int *out){
|
|
if (*begin == end || !isdigit(**begin))
|
|
return false;
|
|
*out = 0;
|
|
while(*begin != end && isdigit(**begin)){
|
|
*out = (*out)*10+(**begin-'0');
|
|
(*begin)++;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PFT_IsHex(char c){
|
|
return isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
|
|
}
|
|
|
|
int PFT_HexCharToInt(char c){
|
|
if (isdigit(c))
|
|
return c-'0';
|
|
if (c >= 'a' && c <= 'f')
|
|
return c-'a'+10;
|
|
if (c >= 'A' && c <= 'F')
|
|
return c-'A'+10;
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
|
|
bool PFT_ReadColorHex(char** begin, char* end, uint32_t *out){
|
|
char* oldbegin = *begin;
|
|
*out = 0;
|
|
if (end-*begin < 6)
|
|
return false;
|
|
for(int i = 0; i != 6; i++){
|
|
if (!PFT_IsHex(**begin)){
|
|
*begin = oldbegin;
|
|
return false;
|
|
}
|
|
*out = (*out)*16+PFT_HexCharToInt(**begin);
|
|
(*begin)++;
|
|
}
|
|
if (end-*begin >= 2 && PFT_IsHex(**begin) && PFT_IsHex(begin[0][1])){
|
|
*out = (*out)*16+PFT_HexCharToInt(**begin);
|
|
(*begin)++;
|
|
*out = (*out)*16+PFT_HexCharToInt(**begin);
|
|
(*begin)++;
|
|
}else{
|
|
*out *= 256;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void PFT_SkipSpace(char **begin, char *end){
|
|
while(*begin != end && **begin == ' '){
|
|
(*begin)++;
|
|
}
|
|
}
|
|
|
|
void PFT_SkipOverNextNewline(char **begin, char *end){
|
|
while(*begin != end && **begin != '\n'){
|
|
(*begin)++;
|
|
}
|
|
if (*begin != end)
|
|
(*begin)++;
|
|
}
|
|
|
|
int PFT_HandlePixelflutMessage(uint8_t *buffer, int size, int sock){
|
|
char *begin = (char*)buffer;
|
|
char *end = begin + size;
|
|
char cmd_buffer[32];
|
|
char response_buffer[100];
|
|
int x, y;
|
|
uint32_t c;
|
|
//packet_size = MIN(offset + (pixellength * MAX_PIXELS), packet_size);
|
|
while ( begin != end ) {
|
|
if (!PFT_ReadIdent(&begin, end, cmd_buffer, 32)){
|
|
PFT_SkipOverNextNewline(&begin, end);
|
|
continue;
|
|
}
|
|
if (strcmp(cmd_buffer, "PX") == 0){
|
|
PFT_SkipSpace(&begin, end);
|
|
if (!PRF_ReadInt(&begin, end, &x)){
|
|
PFT_SkipOverNextNewline(&begin, end);
|
|
continue;
|
|
}
|
|
PFT_SkipSpace(&begin, end);
|
|
if (!PRF_ReadInt(&begin, end, &y)){
|
|
PFT_SkipOverNextNewline(&begin, end);
|
|
continue;
|
|
}
|
|
PFT_SkipSpace(&begin, end);
|
|
if (PFT_ReadColorHex(&begin, end, &c)){
|
|
SetPixel(x, y, c>>8);
|
|
}else{
|
|
c = GetPixel(x, y);
|
|
int len = sprintf(response_buffer, "PX %i %i %06x\n", x, y, c);
|
|
send(sock, response_buffer, len, 0);
|
|
}
|
|
}
|
|
else if (strcmp(cmd_buffer, "SIZE") == 0){
|
|
int len = sprintf(response_buffer, "SIZE %i %i", Nx, Ny);
|
|
send(sock, response_buffer, len, 0);
|
|
|
|
}
|
|
else if (strcmp(cmd_buffer, "HELP") == 0){
|
|
int len = sprintf(response_buffer, "see https://github.com/defnull/pixelflut\n");
|
|
send(sock, response_buffer, len, 0);
|
|
}
|
|
PFT_SkipOverNextNewline(&begin, end);
|
|
}
|
|
return begin-(char*)buffer;
|
|
}
|
|
|
|
void * PFT_HandleClient(int sock){
|
|
PFT_ClientThreadCount++;
|
|
uint8_t buf[1024];
|
|
uint8_t offset = 0;
|
|
int read_size = 0;
|
|
while( (read_size = recv(sock , buf + offset, sizeof(buf) - offset , 0)) > 0){
|
|
offset = PFT_HandlePixelflutMessage(buf, read_size, sock);
|
|
memcpy(buf, buf+read_size-offset, offset);
|
|
}
|
|
close(sock);
|
|
PFT_ClientThreadCount--;
|
|
return 0;
|
|
}
|
|
|
|
|
|
void * PFT_RunServer(unsigned long port){
|
|
int client_sock;
|
|
socklen_t addr_len;
|
|
struct sockaddr_in addr;
|
|
addr_len = sizeof(addr);
|
|
struct timeval tv;
|
|
|
|
fprintf(stderr, "PF: Starting Pixelflut Server...\n");
|
|
|
|
int server_sock = socket(PF_INET, SOCK_STREAM, 0);
|
|
|
|
tv.tv_sec = PFT_CONNECTION_TIMEOUT;
|
|
tv.tv_usec = 0;
|
|
|
|
addr.sin_addr.s_addr = INADDR_ANY;
|
|
addr.sin_port = htons(port);
|
|
addr.sin_family = AF_INET;
|
|
|
|
if (server_sock == -1){
|
|
fprintf(stderr, "PF: socket() failed\n");
|
|
return 0;
|
|
}
|
|
int one = 1;
|
|
if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(int)) < 0)
|
|
fprintf(stderr, "PF: setsockopt(SO_REUSEADDR) failed\n");
|
|
if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(int)) < 0)
|
|
fprintf(stderr, "PF: setsockopt(SO_REUSEPORT) failed\n");
|
|
|
|
int retries;
|
|
for (retries = 0; bind(server_sock, (struct sockaddr*)&addr, sizeof(addr)) == -1 && retries < 10; retries++){
|
|
fprintf(stderr, "PF: bind() failed ...retry in 5s\n");
|
|
usleep(5000000);
|
|
}
|
|
if (retries == 10)
|
|
return 0;
|
|
|
|
if (listen(server_sock, 4) == -1){
|
|
fprintf(stderr, "PF: listen() failed\n");
|
|
return 0;
|
|
}
|
|
fprintf(stderr, "PF: Pixelflut Listening...\n");
|
|
|
|
setsockopt(server_sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv,sizeof(struct timeval));
|
|
setsockopt(server_sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv,sizeof(struct timeval));
|
|
|
|
while(true){
|
|
client_sock = accept(server_sock, (struct sockaddr*)&addr, &addr_len);
|
|
if(client_sock > 0){
|
|
std::thread client_thread(PFT_HandleClient, client_sock);
|
|
client_thread.detach();
|
|
}
|
|
}
|
|
close(server_sock);
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
Nx = atoi(argv[1]);
|
|
Ny = atoi(argv[2]);
|
|
buf = (uint8_t*)malloc(Nx*Ny*3);
|
|
int port = atoi(argv[3]);
|
|
if (port == 0) port = 4444;
|
|
|
|
std::thread pixelflut_tcp_thread(&PFT_RunServer,(unsigned long)port);
|
|
|
|
|
|
while(1) {
|
|
write(1, buf, Nx*Ny*3);
|
|
usleep(33*1000);
|
|
|
|
}
|
|
} |