sddslogserver.c File Reference

Server program to log data to SDDS (Self Describing Data Sets) files. More...

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <sys/stat.h>
#include <dirent.h>
#include "mdb.h"
#include "SDDS.h"
#include "scan.h"

Go to the source code of this file.

Macros
#define	BUFLEN   16384
#define	DISCONNECT   0 /* Disconnect from the server—forces server to terminate the forked process */
#define	ADD_VALUE   1
#define	MAKE_DIRECTORY   2
#define	CHANGE_DIRECTORY   3
#define	GET_TIME_SPAN   4 /* Get values between two times */
#define	GET_LAST_N   5 /* Get last N values */
#define	SDDSPLOT   6 /* Make an sddsplot and return its URL */
#define	ADD_CHANNEL   7
#define	DELETE_VALUE   8
#define	UPDATE_CHD   9
#define	LIST_DIRS   10
#define	LIST_CHANNELS   11
#define	N_COMMANDS   12
#define	CLI_PORT   0
#define	CLI_ROOT   1
#define	CLI_FORBID   2
#define	CLI_SDDSPLOT_PATH   3
#define	N_OPTIONS   4

Functions
int	dostuff (int)
int	createChannel (char *spec)
int	addValue (char *spec)
int	runSddsplot (char *returnBuffer, char *options)
void	updateChannelDescription (void)
int	makeDirectoryList (int64_t *returnNumber, char ***returnBuffer)
int	getChannelList (int64_t *returnNumber, char ***returnBuffer)
void	error (const char *msg, char *progName)
int	writeReply (int sock, const char *message, int code)
int	writeReplyList (int sock, int64_t nItems, char **messageList)
void	freeReplyList (int64_t nItems, char **item)
int	chdirFromRoot (char *path)
void	shutdownServer (int arg)
int	main (int argc, char *argv[])

Variables
char *	rootDir
char *	command [N_COMMANDS]
short	forbid [N_COMMANDS]
char *	option [N_OPTIONS]
const char *	USAGE
char *	sddsplotPath = NULL
static int	sockfd = -1

Detailed Description

Server program to log data to SDDS (Self Describing Data Sets) files.

This program listens on a specified port and handles multiple client connections to log data into SDDS files. It supports various commands such as adding values, creating channels, making directories, and generating SDDS plots.

Features:

• Handles multiple client connections using forked processes.
• Supports dynamic creation and management of SDDS channels.
• Provides command restrictions through the forbid option.
• Generates SDDS plots and returns their URLs.

Usage:

sddslogserver -port=<portNumber> [-root=<rootDirectory>] [-forbid=<command1,command2,...>] [-sddsplotPath=<path>]

Options:

• -port Port number on which the server listens (required).
• -root Path of the root directory (optional, defaults to current directory).
• -forbid Comma-separated list of commands to forbid (optional).
• -sddsplotPath Pathname for SDDS plot output files (optional).

Copyright

• (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
• (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author

M. Borland, R. Soliday

Definition in file sddslogserver.c.

Macro Definition Documentation

ADD_CHANNEL

#define ADD_CHANNEL   7

Definition at line 71 of file sddslogserver.c.

ADD_VALUE

#define ADD_VALUE   1

Definition at line 65 of file sddslogserver.c.

BUFLEN

#define BUFLEN   16384

Definition at line 52 of file sddslogserver.c.

CHANGE_DIRECTORY

#define CHANGE_DIRECTORY   3

Definition at line 67 of file sddslogserver.c.

CLI_FORBID

#define CLI_FORBID   2

Definition at line 164 of file sddslogserver.c.

CLI_PORT

#define CLI_PORT   0

Definition at line 162 of file sddslogserver.c.

CLI_ROOT

#define CLI_ROOT   1

Definition at line 163 of file sddslogserver.c.

CLI_SDDSPLOT_PATH

#define CLI_SDDSPLOT_PATH   3

Definition at line 165 of file sddslogserver.c.

DELETE_VALUE

#define DELETE_VALUE   8

Definition at line 72 of file sddslogserver.c.

DISCONNECT

#define DISCONNECT   0 /* Disconnect from the server—forces server to terminate the forked process */

Definition at line 64 of file sddslogserver.c.

GET_LAST_N

#define GET_LAST_N   5 /* Get last N values */

Definition at line 69 of file sddslogserver.c.

GET_TIME_SPAN

#define GET_TIME_SPAN   4 /* Get values between two times */

Definition at line 68 of file sddslogserver.c.

LIST_CHANNELS

#define LIST_CHANNELS   11

Definition at line 75 of file sddslogserver.c.

LIST_DIRS

#define LIST_DIRS   10

Definition at line 74 of file sddslogserver.c.

MAKE_DIRECTORY

#define MAKE_DIRECTORY   2

Definition at line 66 of file sddslogserver.c.

N_COMMANDS

#define N_COMMANDS   12

Definition at line 76 of file sddslogserver.c.

N_OPTIONS

#define N_OPTIONS   4

Definition at line 166 of file sddslogserver.c.

SDDSPLOT

#define SDDSPLOT   6 /* Make an sddsplot and return its URL */

Definition at line 70 of file sddslogserver.c.

UPDATE_CHD

#define UPDATE_CHD   9

Definition at line 73 of file sddslogserver.c.

Function Documentation

addValue()

int addValue

(

char *

spec

)

Definition at line 512 of file sddslogserver.c.

{
  char *ptr;
  char buffer[BUFLEN];
  int32_t type;
  int64_t rows;
  SDDS_DATASET SDDSin;
  void *data = NULL;
 
  if (!(ptr = strchr(spec, ',')))
    return 1;
  *ptr++ = 0;
 
  snprintf(buffer, sizeof(buffer), "%s.sdds", spec);
  if (!SDDS_InitializeAppendToPage(&SDDSin, buffer, 1, &rows)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 2;
  }
  printf("Initialized, %" PRId64 " rows\n", rows);
  fflush(stdout);
  if (!SDDS_LengthenTable(&SDDSin, 1)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 3;
  }
  printf("Lengthened table\n");
  fflush(stdout);
 
  if (SDDS_GetColumnInformation(&SDDSin, "type", &type, SDDS_GET_BY_NAME, spec) != SDDS_LONG) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    SDDS_Terminate(&SDDSin);
    return 4;
  }
  printf("Got type information\n");
  fflush(stdout);
 
  if (type != SDDS_STRING)
    data = SDDS_Malloc(SDDS_type_size[type - 1]);
  if (SDDS_ScanData(ptr, type, 0, data, 0, 0) == 0) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    SDDS_Terminate(&SDDSin);
    return 5;
  }
  printf("Scanned data\n");
  fflush(stdout);
 
  if (!SDDS_SetRowValues(&SDDSin, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, rows, "SampleIDNumber", rows, "Time", getTimeInSecs(), NULL)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    SDDS_Terminate(&SDDSin);
    return 6;
  }
  printf("Set row values\n");
  fflush(stdout);
 
  switch (type) {
  case SDDS_STRING:
    if (!SDDS_SetRowValues(&SDDSin, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, rows, spec, ptr, NULL)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 7;
    }
    break;
  case SDDS_FLOAT:
    if (!SDDS_SetRowValues(&SDDSin, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, rows, spec, *((float *)data), NULL)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 7;
    }
    break;
  case SDDS_DOUBLE:
    if (!SDDS_SetRowValues(&SDDSin, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, rows, spec, *((double *)data), NULL)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 7;
    }
    break;
  case SDDS_SHORT:
    if (!SDDS_SetRowValues(&SDDSin, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, rows, spec, *((short *)data), NULL)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 7;
    }
    break;
  case SDDS_LONG:
    if (!SDDS_SetRowValues(&SDDSin, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, rows, spec, *((int32_t *)data), NULL)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 7;
    }
    break;
  case SDDS_LONG64:
    if (!SDDS_SetRowValues(&SDDSin, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, rows, spec, *((int64_t *)data), NULL)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 7;
    }
    break;
  default:
    break;
  }
  printf("Set row value\n");
  fflush(stdout);
  if (data)
    free(data);
 
  if (!SDDS_UpdatePage(&SDDSin, FLUSH_TABLE)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 8;
  }
  printf("Updated page\n");
  fflush(stdout);
  if (!SDDS_Terminate(&SDDSin)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 9;
  }
  printf("Terminated\n");
  fflush(stdout);
  return 0;
}

chdirFromRoot()

int chdirFromRoot

(

char *

path

)

Definition at line 155 of file sddslogserver.c.

                              {
  char buffer[BUFLEN];
  snprintf(buffer, sizeof(buffer), "%s/%s", rootDir, (path && *path) ? path : "");
  fprintf(stderr, "Changing directory to %s\n", buffer);
  return chdir(buffer);
}

createChannel()

int createChannel

(

char *

spec

)

Definition at line 458 of file sddslogserver.c.

{
  char *chName, *chType, *chUnits, *chDescription;
  char buffer[BUFLEN];
  SDDS_DATASET SDDSout;
  int32_t type;
 
  chName = spec;
  if (!(chType = strchr(spec, ',')))
    return 1;
  *chType++ = 0;
  if (!(chUnits = strchr(chType, ',')))
    return 2;
  *chUnits++ = 0;
  if ((type = SDDS_IdentifyType(chType)) == 0)
    return 2;
  if (!(chDescription = strchr(chUnits, ',')))
    return 3;
  *chDescription++ = 0;
 
  if (strcmp(chName, "Time") == 0)
    return 4;
 
  snprintf(buffer, sizeof(buffer), "%s.sdds", chName);
  if (fexists(buffer))
    return 5;
 
  if (!SDDS_InitializeOutput(&SDDSout, SDDS_BINARY, 0, NULL, NULL, buffer) ||
      !SDDS_DefineSimpleColumn(&SDDSout, "SampleIDNumber", NULL, SDDS_LONG64) ||
      !SDDS_DefineSimpleColumn(&SDDSout, "Time", "s", SDDS_DOUBLE) ||
      SDDS_DefineColumn(&SDDSout, chName, NULL, chUnits, chDescription, NULL, type, 0) < 0 ||
      !SDDS_WriteLayout(&SDDSout) ||
      !SDDS_StartPage(&SDDSout, 1) ||
      !SDDS_WritePage(&SDDSout) ||
      !SDDS_Terminate(&SDDSout))
    return 6;
 
  snprintf(buffer, sizeof(buffer), "sddsquery %s.sdds -sddsOutput=%s.chd -column", chName, chName);
  system(buffer);
  snprintf(buffer, sizeof(buffer), "%s.chd", chName);
  if (!fexists(buffer))
    return 6;
 
  updateChannelDescription();
 
  return 0;
}

dostuff()

int dostuff

(

int

sock

)

Definition at line 340 of file sddslogserver.c.

                      {
  int n, code;
  char buffer[BUFLEN];
  char *ptr1;
  short persist = 1;
  int64_t nItems;
  char **itemValue;
 
  while (persist) {
    memset(buffer, 0, BUFLEN);
    n = read(sock, buffer, BUFLEN - 1);
    if (n < 0)
      error("ERROR reading from socket", "sddslogserver");
    if (strlen(buffer) == 0)
      continue;
    chop_nl(buffer);
    printf("Here is the message: <%s>\n", buffer);
 
    if ((ptr1 = strchr(buffer, ':')))
      *ptr1++ = 0;
    if ((code = match_string(buffer, command, N_COMMANDS, EXACT_MATCH)) < 0 || forbid[code]) {
      writeReply(sock, "Forbidden operation.", 0);
      continue;
    }
    switch (code) {
    case DISCONNECT:
      printf("Disconnecting\n");
      fflush(stdout);
      persist = 0;
      break;
    case ADD_VALUE:
      /* syntax: channel=value */
      printf("Add value: %s\n", ptr1);
      if ((code = addValue(ptr1)) == 0)
        writeReply(sock, "ok", code);
      else
        writeReply(sock, "Error: Failed to add value.", code);
      break;
    case DELETE_VALUE:
      /* syntax: channel,sampleID */
      printf("Delete value: %s\n", ptr1);
      writeReply(sock, "Error: Can't do that yet.", EXIT_FAILURE);
      break;
    case ADD_CHANNEL:
      /* syntax: channel,type */
      printf("Add channel: %s\n", ptr1);
      if ((code = createChannel(ptr1)) == 0)
        writeReply(sock, "ok", code);
      else
        writeReply(sock, "Error: Failed to create channel.", code);
      break;
    case MAKE_DIRECTORY:
      /* syntax: directoryName */
      printf("Make directory: %s\n", ptr1);
      if ((code = mkdir(ptr1, 0700))) {
        writeReply(sock, "Error: Making directory.", code);
      } else {
        writeReply(sock, "ok", code);
      }
      break;
    case CHANGE_DIRECTORY:
      /* syntax: path */
      if (ptr1 && *ptr1 && strstr(ptr1, "..")) {
        /* Only absolute paths are allowed */
        writeReply(sock, "Error: Relative paths not supported.", EXIT_FAILURE);
      } else {
        printf("Change directory: %s\n", ptr1 && *ptr1 ? ptr1 : "base");
        if ((code = chdirFromRoot(ptr1)))
          writeReply(sock, "Error: CD failed.", code);
        else
          writeReply(sock, "CD ok.", code);
      }
      break;
    case GET_TIME_SPAN:
      /* syntax: channel,startTime,endTime */
      printf("Get time span: %s\n", ptr1);
      writeReply(sock, "Error: Can't do that yet.", EXIT_FAILURE);
      break;
    case GET_LAST_N:
      /* syntax: channel,N; if N<=0, return all data */
      printf("Get last N: %s\n", ptr1);
      writeReply(sock, "Error: Can't do that yet.", EXIT_FAILURE);
      break;
    case SDDSPLOT:
      /* syntax:<sddsplotCommand> */
      printf("sddsplot: %s\n", ptr1);
      code = runSddsplot(buffer, ptr1);
      writeReply(sock, buffer, code);
      break;
    case UPDATE_CHD:
      updateChannelDescription();
      writeReply(sock, "ok", EXIT_SUCCESS);
      break;
    case LIST_DIRS:
      if (makeDirectoryList(&nItems, &itemValue))
        writeReply(sock, "Failed to retrieve directory list.", EXIT_FAILURE);
      else {
        writeReplyList(sock, nItems, itemValue);
        freeReplyList(nItems, itemValue);
      }
      break;
    case LIST_CHANNELS:
      if (getChannelList(&nItems, &itemValue))
        writeReply(sock, "Failed to retrieve channel list.", EXIT_FAILURE);
      else {
        writeReplyList(sock, nItems, itemValue);
        freeReplyList(nItems, itemValue);
      }
      break;
    default:
      printf("Unknown command: %s\n", buffer);
      writeReply(sock, "Error: Unknown command.", EXIT_FAILURE);
      break;
    }
  }
  return EXIT_SUCCESS;
}

error()

void error	(	const char *	msg,
		char *	progName )

Definition at line 108 of file sddslogserver.c.

                                            {
  char s[BUFLEN];
  snprintf(s, sizeof(s), "%s (%s)", msg, progName);
  perror(s);
  exit(EXIT_FAILURE);
}

freeReplyList()

void freeReplyList	(	int64_t	nItems,
		char **	item )

Definition at line 145 of file sddslogserver.c.

                                                {
  int64_t i;
  if (!item)
    return;
  for (i = 0; i < nItems; i++)
    if (item[i])
      free(item[i]);
  free(item);
}

getChannelList()

int getChannelList	(	int64_t *	returnNumber,
		char ***	returnBuffer )

Definition at line 729 of file sddslogserver.c.

                                                                {
  SDDS_DATASET SDDSin;
 
  *returnBuffer = NULL;
  *returnNumber = 0;
 
  updateChannelDescription();
  if (!fexists("allChd.sdds"))
    return 0;
  if (!SDDS_InitializeInput(&SDDSin, "allChd.sdds")) {
    printf("Problem reading allChd.sdds\n");
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 1;
  }
  if (SDDS_ReadPage(&SDDSin) < 0)
    /* Assume file is empty */
    return 0;
  if ((*returnNumber = SDDS_RowCount(&SDDSin)) < 0) {
    printf("Row count: %" PRId64 "\n", *returnNumber);
    return 2;
  }
  if (*returnNumber == 0)
    return 0;
  if (!(*returnBuffer = SDDS_GetColumn(&SDDSin, "Name"))) {
    printf("Problem getting Name\n");
    return 3;
  }
  return 0;
}

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 198 of file sddslogserver.c.

                                 {
  int newsockfd, portno, pid;
  int reuse = 1;
  socklen_t clilen;
  struct sockaddr_in serv_addr, cli_addr;
  int i_arg, j, code;
  SCANNED_ARG *s_arg;
 
  /* Allow zombie children to die */
  signal(SIGCHLD, SIG_IGN);
  signal(SIGINT, shutdownServer);
 
  /* Parse arguments */
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&s_arg, argc, argv);
  if (argc < 2) {
    fprintf(stderr, "%s", USAGE);
    exit(EXIT_FAILURE);
  }
 
  portno = -1;
  rootDir = NULL;
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (s_arg[i_arg].arg_type == OPTION) {
      switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
      case CLI_PORT:
        if (s_arg[i_arg].n_items != 2 ||
            sscanf(s_arg[i_arg].list[1], "%d", &portno) != 1 ||
            portno <= 0) {
          fprintf(stderr, "Error: Invalid syntax/values for -port argument\n%s", USAGE);
          exit(EXIT_FAILURE);
        }
        break;
      case CLI_ROOT:
        if (s_arg[i_arg].n_items != 2 ||
            strlen(rootDir = s_arg[i_arg].list[1]) == 0) {
          fprintf(stderr, "Error: Invalid syntax/values for -root argument\n%s", USAGE);
          exit(EXIT_FAILURE);
        }
        break;
      case CLI_FORBID:
        if (s_arg[i_arg].n_items < 2) {
          fprintf(stderr, "Error: Invalid syntax/values for -forbid argument\n%s", USAGE);
          exit(EXIT_FAILURE);
        }
        for (j = 1; j < s_arg[i_arg].n_items; j++) {
          if ((code = match_string(s_arg[i_arg].list[j], command, N_COMMANDS, 0)) < 0) {
            fprintf(stderr, "Error: Unknown command for -forbid: %s\n", s_arg[i_arg].list[j]);
            exit(EXIT_FAILURE);
          }
          forbid[code] = 1;
        }
        break;
      case CLI_SDDSPLOT_PATH:
        if (s_arg[i_arg].n_items != 2) {
          fprintf(stderr, "Error: Invalid syntax for -sddsplotPath option\n%s", USAGE);
          exit(EXIT_FAILURE);
        }
        sddsplotPath = s_arg[i_arg].list[1];
        break;
      default:
        fprintf(stderr, "Invalid or ambiguous option: %s\n%s", s_arg[i_arg].list[0], USAGE);
        exit(EXIT_FAILURE);
        break;
      }
    } else {
      fprintf(stderr, "Invalid or ambiguous option: %s\n%s", s_arg[i_arg].list[0], USAGE);
      exit(EXIT_FAILURE);
    }
  }
 
  if (!rootDir) {
    cp_str(&rootDir, ".");
  }
  if (!fexists(rootDir))
    error("Error: Root directory not found", argv[0]);
  chdir(rootDir);
 
  /* Create socket */
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd < 0)
    error("Error opening socket", argv[0]);
  printf("sockfd = %d\n", sockfd);
  memset(&serv_addr, 0, sizeof(serv_addr));
 
  /* Set the socket to SO_REUSEADDR */
  if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuse, sizeof(reuse)) < 0)
    perror("setsockopt(SO_REUSEADDR) failed");
 
#ifdef SO_REUSEPORT
  if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, (const char *)&reuse, sizeof(reuse)) < 0)
    perror("setsockopt(SO_REUSEPORT) failed");
#endif
 
  /* Bind the socket to a port number */
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_addr.s_addr = INADDR_ANY;
  serv_addr.sin_port = htons(portno);
  if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    error("Error on port binding. Check port number.", argv[0]);
 
  listen(sockfd, 5);
  clilen = sizeof(cli_addr);
  while (1) {
    printf("Waiting for new socket connection\n");
    fflush(stdout);
    newsockfd = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen);
    printf("Got new socket connection\n");
    fflush(stdout);
    if (newsockfd < 0) {
      if (sockfd >= 0)
        close(sockfd);
      error("Error on accept", argv[0]);
    }
    pid = fork();
    if (pid < 0)
      error("Error on fork", argv[0]);
    if (pid == 0) {
      close(sockfd);
      dostuff(newsockfd);
      printf("Returned from dostuff\n");
      fflush(stdout);
      exit(EXIT_SUCCESS);
    } else {
      printf("Forked process\n");
      fflush(stdout);
      close(newsockfd);
    }
  } /* end of while */
  printf("Exited while loop\n");
  fflush(stdout);
  if (sockfd > 0)
    close(sockfd);
  return EXIT_SUCCESS; /* We never get here */
}

makeDirectoryList()

int makeDirectoryList	(	int64_t *	returnNumber,
		char ***	returnBuffer )

Definition at line 695 of file sddslogserver.c.

                                                                   {
  SDDS_DATASET SDDSin;
  char command[BUFLEN];
 
  if (returnNumber)
    *returnNumber = 0;
  if (returnBuffer)
    *returnBuffer = NULL;
 
  remove("dirList.sdds");
  snprintf(command, sizeof(command),
           "find . -type d -maxdepth 1 | tail -n +2 | plaindata2sdds -pipe=in dirList.sdds -input=ascii -column=DirectoryName,string -norow");
  system(command);
  if (!SDDS_InitializeInput(&SDDSin, "dirList.sdds")) {
    printf("Problem reading dirList.sdds\n");
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 1;
  }
  if (SDDS_ReadPage(&SDDSin) < 0)
    /* Assume file is empty */
    return 0;
  if ((*returnNumber = SDDS_RowCount(&SDDSin)) < 0) {
    printf("Row count: %" PRId64 "\n", *returnNumber);
    return 2;
  }
  if (*returnNumber == 0)
    return 0;
  if (!(*returnBuffer = SDDS_GetColumn(&SDDSin, "DirectoryName"))) {
    printf("Problem getting DirectoryName\n");
    return 3;
  }
  return 0;
}

runSddsplot()

int runSddsplot	(	char *	returnBuffer,
		char *	options )

Definition at line 629 of file sddslogserver.c.

                                                   {
    char command[BUFLEN];
    char template[BUFLEN];
    int fd;
 
    // Ensure sddsplotPath is set
    if (!sddsplotPath) {
        fprintf(stderr, "Error: sddsplotPath is not set.\n");
        return 1;
    }
 
    // Create the template with sddsplotPath and "png-XXXXXX.png"
    // mkstemps requires the template to end with "XXXXXX" followed by the suffix
    snprintf(template, sizeof(template), "%s/png-XXXXXX.png", sddsplotPath);
 
    // Create a mutable copy of the template for mkstemps
    char *tempTemplate = strdup(template);
    if (!tempTemplate) {
        perror("strdup");
        return 1;
    }
 
    // mkstemps replaces "XXXXXX" with a unique suffix and keeps the ".png" extension
    fd = mkstemps(tempTemplate, 4); // 4 is the length of ".png"
    if (fd == -1) {
        perror("mkstemps");
        free(tempTemplate);
        return 1;
    }
 
    // Close the file descriptor as we don't need it
    close(fd);
 
    // tempTemplate now contains the unique filename with ".png"
    snprintf(command, sizeof(command), "sddsplot -device=png -output=%s %s", tempTemplate, options);
    printf("Executing: %s\n", command);
    fflush(stdout);
 
    // Copy the filename to returnBuffer
    strncpy(returnBuffer, tempTemplate, BUFLEN - 1);
    returnBuffer[BUFLEN - 1] = '\0';
 
    // Free the duplicated template
    free(tempTemplate);
 
    // Execute the command
    return system(command);
}

shutdownServer()

void shutdownServer

(

int

arg

)

Definition at line 190 of file sddslogserver.c.

                             {
  printf("Closing sockfd=%d\n", sockfd);
  fflush(stdout);
  if (sockfd >= 0)
    close(sockfd);
  exit(EXIT_SUCCESS);
}

updateChannelDescription()

void updateChannelDescription

(

void

)

Definition at line 507 of file sddslogserver.c.

                                    {
  char *command = "sddscombine *.chd -merge -pipe=out | sddsprocess -pipe=in -match=col,Name=SampleIDNumber,! -match=col,Name=Time,! allChd.sdds";
  system(command);
}

writeReply()

int writeReply	(	int	sock,
		const char *	message,
		int	code )

Definition at line 115 of file sddslogserver.c.

                                                        {
  char buffer[BUFLEN + 20];
  if (code) {
    snprintf(buffer, sizeof(buffer), "error:%s (code %d)\n", message, code);
    return write(sock, buffer, strlen(buffer));
  } else {
    // snprintf(buffer, sizeof(buffer), "ok:%s\n", message);
    return write(sock, message, strlen(message));
  }
}

writeReplyList()

int writeReplyList	(	int	sock,
		int64_t	nItems,
		char **	messageList )

Definition at line 126 of file sddslogserver.c.

                                                                 {
  int64_t i;
  char message[BUFLEN];
  strncpy(message, "ok:", sizeof(message) - 1);
  message[sizeof(message) - 1] = 0;
 
  /* Need to check for buffer overflow */
  printf("%" PRId64 " reply items\n", nItems);
  for (i = 0; i < nItems; i++) {
    printf("Item %" PRId64 ": %s\n", i, messageList[i]);
    strncat(message, messageList[i], sizeof(message) - strlen(message) - 1);
    if (i != (nItems - 1))
      strncat(message, ",", sizeof(message) - strlen(message) - 1);
  }
  strncat(message, "\n", sizeof(message) - strlen(message) - 1);
  printf("message: %s", message);
  return write(sock, message, strlen(message));
}

Variable Documentation

command

char* command[N_COMMANDS]

Initial value:

= {
  "disconnect",
  "addValue",
  "mkdir",
  "cd",
  "getTimeSpan",
  "getLastN",
  "sddsplot",
  "addChannel",
  "deleteValue",
  "updateChDesc",
  "listDirs",
  "listChannels",
}

Definition at line 78 of file sddslogserver.c.

                            {
  "disconnect",
  "addValue",
  "mkdir",
  "cd",
  "getTimeSpan",
  "getLastN",
  "sddsplot",
  "addChannel",
  "deleteValue",
  "updateChDesc",
  "listDirs",
  "listChannels",
};

forbid

short forbid[N_COMMANDS]

Initial value:

= {
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
}

Definition at line 93 of file sddslogserver.c.

                           {
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
};

option

char* option[N_OPTIONS]

Initial value:

= {
  "port",
  "root",
  "forbid",
  "sddsplotpath"
}

Definition at line 168 of file sddslogserver.c.

                          {
  "port",
  "root",
  "forbid",
  "sddsplotpath"
};

rootDir

char* rootDir

Definition at line 62 of file sddslogserver.c.

sddsplotPath

char* sddsplotPath = NULL

Definition at line 186 of file sddslogserver.c.

sockfd

int sockfd = -1

static

Definition at line 188 of file sddslogserver.c.

USAGE

const char* USAGE

Initial value:

=
  "Usage: sddslogserver -port=<portNumber> [-root=<rootDirectory>] \n"
  "                    [-forbid=<command1,command2,...>] \n"
  "                    [-sddsplotPath=<path>]\n\n"
  "Options:\n"
  "  -port          Port number on which the server listens (required).\n"
  "  -root          Path of the root directory (optional, defaults to current directory).\n"
  "  -forbid        Comma-separated list of commands to forbid (optional).\n"
  "  -sddsplotPath  Pathname for SDDS plot output files (optional).\n\n"
  "Program by Michael Borland. (" __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION ")\n"

Definition at line 175 of file sddslogserver.c.