ngcb.h

Go to the documentation of this file.

#ifndef ngcb_h
#define ngcb_h
 
 
 
 
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <signal.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <byteswap.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef USE
#define USE(x) do {(void)(x);} while (0)
#endif
 
#ifdef _LARGEFILE64_SOURCE
typedef off64_t ngcb_off_t;
typedef struct stat64 ngcb_stat_t;
typedef struct statvfs64 ngcb_statvfs_t;
#define ngcb_open(p,m) open64(p,m)
#define ngcb_lseek(f,o,w) lseek64(f,o,w)
#define ngcb_ftruncate(f,l) ftruncate64(f,l)
#define ngcb_fopen(p,m) fopen64(p,m)
#define ngcb_ftello(s) ftello64(s)
#define ngcb_fseeko(s,o,w) fseeko64(s,o,w)
#define ngcb_stat(p,s) stat64(p,s)
#define ngcb_statvfs(p,s) statvfs64(p,s)
#define ngcb_mmap(s,l,p,fl,fd,o) mmap64(s,l,p,fl,fd,o)
#else
typedef off_t ngcb_off_t;
typedef struct stat ngcb_stat_t;
typedef struct statvfs ngcb_statvfs_t;
#define ngcb_open(p,m) open(p,m)
#define ngcb_lseek(f,o,w) lseek(f,o,w)
#define ngcb_fopen(p,m) fopen(p,m)
#define ngcb_ftello(s) ftello(s)
#define ngcb_fseeko(s,o,w) fseeko(s,o,w)
#define ngcb_ftruncate(s,o) ftruncate(s,o)
#define ngcb_stat(p,s) stat(p,s)
#define ngcb_statvfs(p,s) statvfs(p,s)
#define ngcb_mmap(s,l,p,fl,fd,o) mmap(s,l,p,fl,fd,o) 
#endif

typedef union
{
  int val;
  struct semid_ds *buf;
  unsigned short *array;
} ngcbSEMIPC_CTL;

#ifndef str2str
#define str2str(s1, s2, n) ngcbStr2Str(s1, s2, n)
#endif

#define _vecsize(x) (sizeof(x)/sizeof(x[0]))

typedef int (*ngcb_sig_t)(int how, const sigset_t *set, sigset_t *oset);

typedef int (*ngcb_fct)(void);

typedef void (*ngcb_void_fct)(void);

extern int ngcbVerboseFlag;
 
/*
 * Conversion macros to log code position
 */
#define _ngcb_cv(a) #a
#define _ngcb_tostr(a) _ngcb_cv(a) 

#define NGCB_CODE_POS __FILE__ ":" _ngcb_tostr(__LINE__)
 
 
#ifndef NO_VERBOSE

#define ngcbLog(...) do {if (ngcbVerboseFlag) fprintf(stdout, __VA_ARGS__);} while (0)
 
#else

#define ngcbLog(...) do {} while (0)
 
#endif

#define ngcbFmt(...) (snprintf(__VA_ARGS__) < 0 ? abort() : (void)0)
 
/*
 * Return codes
 */
#define ngcbSUCCESS      0  
#define ngcbABORTED      1  
#define ngcbFAILURE     -1  
#define ngcbWARNING     -2  
#define ngcbSKIP        -3  
#define ngcbERR_SEVERE  -4  
#define ngcbERR_ACCESS  -5  
#define ngcbDISCONNECT  -6  
 
/*
 * String types
 */
typedef char ngcb_str32_t[32];    
typedef char ngcb_str64_t[64];    
typedef char ngcb_str128_t[128];  
typedef char ngcb_str256_t[256];  
typedef char ngcb_str512_t[512];  
 
/*
 * Keyword parser
 */
#define ngcbMAX_KEY_LEN     256   
#define ngcbMAX_KEYELE_LEN  512   
 
/*
 * FITS keyword types
 */
#define ngcbFITS_TYPE_INT      1  
#define ngcbFITS_TYPE_FLOAT    2  
#define ngcbFITS_TYPE_DOUBLE   3  
#define ngcbFITS_TYPE_STRING   4  
#define ngcbFITS_TYPE_LOGICAL  5  
#define ngcbFITS_TYPE_FREE     6  
#define ngcbFITS_TYPE_COMMENT  7   

#define ngcbFITS_LINE_LEN 80

#define ngcbFITS_KEY_SIZE 48

#define ngcbFITS_BLOCK_LINES 36

#define ngcbFITS_BLOCK_LEN (ngcbFITS_LINE_LEN * ngcbFITS_BLOCK_LINES)
 
/*
 * Timer functions
 */

typedef struct {
  long tv_sec;   
  long tv_usec;  
} ngcb_time_v;

typedef struct {
  long tv_sec;   
  long tv_nsec;  
} ngcb_time_hr;

int ngcbTaiOffset();

int ngcbGetTime(struct timeval *t);

void ngcbSubTime(struct timeval t1, struct timeval t2, struct timeval *t3);

void ngcbAddTime(struct timeval t1, struct timeval t2, struct timeval *t3);

void ngcbAddTimeFrac(uint64_t *sec, uint64_t *nsec, double t);

void ngcbTimeFrac2Str(char *value, uint64_t sec, uint64_t nsec);

void ngcbAddSec(struct timeval *t, double seconds);

int ngcbGetUTC(char *utc, int precision);

double ngcbGetMJD(void);

void ngcbTime2UTC(struct timeval t, char *utc, int precision);

double ngcbTime2MJD(struct timeval t);

void ngcbMJD2UTC(double mjd, char *utc, int precision);

double ngcbUTC2MJD(const char *utc);

int ngcbMicroSleep(int fd, int waitTime);

int ngcbSleep(int fd, int waitTime);

#define ngcbDiffTime(t1,t2) ((double)(t2.tv_sec - t1.tv_sec) + \
                 ((double)(t2.tv_usec - t1.tv_usec)/1.0e6))

#define ngcbDiffTimeHR(t1,t2) ((double)(t2.tv_sec - t1.tv_sec) + \
                   ((double)(t2.tv_nsec - t1.tv_nsec)/1.0e9))
 

FILE *ngcbDebugOpen(char *erms);

void ngcbDebugClose(FILE *debugStream);

void ngcbPrint(FILE *fd, void *buffer, size_t size, int bitPix, size_t max);
 
/*
 * Process monitoring
 */

FILE *ngcbWatchdogOpen(int verbose, char *erms);

void ngcbWatchdogClose(FILE *wd);

void ngcbWatchdogAddProc(FILE *wd, const char *host, int pid);

void ngcbWatchdogRemoveProc(FILE *wd, const char *host, int pid);

void ngcbWatchdogClearProc(FILE *wd, const char *host);

void ngcbWatchdogAddCmd(FILE *wd, const char *host, const char *cmd);

void ngcbWatchdogRemoveCmd(FILE *wd, const char *host, const char *cmd);

void ngcbWatchdogClearCmd(FILE *wd, const char *host);

void ngcbWatchdogDbWrite(FILE *wd, const char *host, const char *attr, 
             const char *value);
 
 
/*
 * Byte swap and type casting
 */
 
/*
 * Architecture (endianess)
 */
#define ngcbLITTLE_ENDIAN  0   
#define ngcbBIG_ENDIAN     1   
#define ngcbMEMCPY         0   
#define ngcbNETCPY         1   
#define ngcbSCPY           2   

int ngcbEndian(void);

void ngcbSwap2(void *buffer, size_t length);

void ngcbSwap4(void *buffer, size_t length);

void ngcbSwap8(void *buffer, size_t length);

void ngcbInt2Bin(char *str, int in);

void ngcbUInt2Bin(char *str, unsigned int in);

int ngcbBin2Int(const char *str);

unsigned int ngcbBin2UInt(const char *str);
 
/*
 * Math functions
 */

typedef struct {
  double *v;  
  double m;   
  int size;   
  int idx;    
  int n;      
} ngcb_ma_t;

void ngcbFilterInit(ngcb_ma_t *f, int size);

void ngcbFilterDelete(ngcb_ma_t *f);

void ngcbFilterReset(ngcb_ma_t *f);

double ngcbFilter(ngcb_ma_t *f, double value);

typedef struct {
  int *v;    
  int m;     
  int size;  
  int *idx;  
  int n;     
} ngcb_rm_t;

void ngcbMedianInit(ngcb_rm_t *f, int size);

void ngcbMedianDelete(ngcb_rm_t *f);

void ngcbMedianReset(ngcb_rm_t *f);

int ngcbRunningMedian(ngcb_rm_t *f, int value);

int ngcbRound(double x);

int ngcbRoundL(long double x);

int64_t ngcbRound64(double x);

int64_t ngcbRound64L(long double x);

double ngcbMean16(unsigned short *a, int n);

double ngcbMean32(int *a, int n);

double ngcbMeanR32(float *a, int n);

double ngcbMeanR64(double *a, int n);

unsigned short ngcbMedian16(unsigned short *a, int n);

int ngcbMedian32(int *a, int n);

float ngcbMedianR32(float *a, int n);
 
/*
 * Remote execution
 */

int ngcbExecDaemon(int bg);

void ngcbExecShell(const char *shell);

int ngcbExecInit(const char *host, int *version, char *erms);

int ngcbExecVersion(const char *host, char *erms);

int ngcbExecutor(int argc, char **argv);

int ngcbExec(const char *host, int *pid, const char *cmd, char *reply, 
         char *erms);

int ngcbExecDbg(const char *host, int *pid, const char *cmd, char *reply, 
        int port, char *erms);
int ngcbExecXt(const char *host, int *pid, const char *cmd, char *reply, 
           const char *geom, char *erms);

int ngcbKill(const char *host, int pid, char *erms);

void ngcbExecReply(int fd, int success, const char *reply);

int ngcbRemoteFileOpen(const char *host, const char *fileName, 
               size_t *size, char *erms);

void ngcbRemoteFileClose(int fd);

int ngcbRemoteFileDelete(const char *host, const char *fileName, char *erms);
 
 
/*
 * File access
 */

int ngcbLoadFile(const char *fileName, char *buffer, size_t *size, char *erms);

int ngcbWriteFile(const char *fileName, const char *buffer, size_t size, 
          char *erms);

int ngcbMapFile(const char *fileName, char **buffer, size_t *size, 
        char * erms);

void ngcbUnmapFile(int fd, char *buffer, size_t size);

long int ngcbFileSize(const char *fileName, char *erms);

ssize_t ngcbRead(int fd, void *buffer, size_t size, char *erms);

ssize_t ngcbWrite(int fd, const void *buffer, size_t size, char *erms);

const char *ngcbGetFileExt(const char *fileName);

const char *ngcbProcName(const char *path);

void ngcbParentDir(char *path, const char *fileName);

int ngcbMkDir(const char *path, mode_t mode, char *erms);

int ngcbFileExists(const char *path);

int ngcbIsDir(const char *path);

int ngcbReadPerm(const char *path);

int ngcbWritePerm(const char *path);

void ngcbExpand(char *path);

int ngcbPathCmp(const char *path1, const char *path2);

double ngcbDiskSpace(const char *path, char *erms);

void ngcbCleanPath(char *name);

int ngcbSkipFd(FILE *stream);

int ngcbWin2File(FILE *fd, const char *buffer, size_t fx, size_t fy, 
         int bitPix, size_t sx, size_t sy, size_t nx, size_t ny, 
         int rot, char *erms);

void *ngcbFileBufAlloc(size_t size, char *erms);

void ngcbFileBufFree(void *buffer);

int ngcbFdCnt(void);

int ngcbFindIndex(const char *path, int minIndex, char *erms);
 
 
 
/*
 * String functions
 */

void ngcbToLower(char *s);

void ngcbToUpper(char *s);

void ngcbCleanSpace(char *s);

void ngcbTrimSpace(char *s);

void ngcbStr2Arg(char *s, int *argc, char **argv);

void ngcbStrPut(char *s1, const char *s2);

int ngcbReplaceEnv(char *string, char *erms);

int ngcbIsFloat(const char *s);

int ngcbStr2Int(const char *s, int *value);

char *ngcbStr2Str(char *s1, const char *s2, size_t n);

int ngcbStr2UInt(const char *s, unsigned int *value);

int ngcbHex2Int(const char *s, int *value);

int ngcbHex2UInt(const char *s, unsigned int *value);

int ngcbFmt2Int(const char *s, int *value);

int ngcbFmt2UInt(const char *s, unsigned int *value);

int ngcbStr2Int16(const char *s, short *value);

int ngcbStr2UInt16(const char *s, unsigned short *value);

int ngcbHex2Int16(const char *s, short *value);

int ngcbHex2UInt16(const char *s, unsigned short *value);

int ngcbStr2Float(const char *s, float *value);

int ngcbStr2Double(const char *s, double *value);

int ngcbF2S(const char *s, const char *filter, char *v);

int ngcbF2Int(const char *s, const char *filter);

unsigned int ngcbF2UInt(const char *s, const char *filter);

int ngcbF2Double(const char *s, const char *filter, double *v);

int ngcbStr2Frac(const char *value, unsigned int n, uint64_t *v1, 
         uint64_t *v2);
 
/*
 * RPC conversion functions
 */

void ngcbRpcCopy(void *dest, const void *src, size_t size, size_t items,
         int how);

int ngcbStr2PayloadItem(const char *arg, unsigned char *payload,
            unsigned int max, int how, char *erms);
  
int ngcbStr2Payload(const char *cmd, unsigned char *payload, unsigned int max,
            int how, char *erms);
 
int ngcbStr2Rpc(const char *cmd, int *delay, int *target, int *req,
        unsigned int *size, char *erms);
  
/*
 * Disk-memory extension
 */

int ngcbDiskMemCreate(const char *path, int idx, unsigned int size, 
              unsigned int chunk, char *erms);

void ngcbDiskMemDelete(const char *path, int idx, unsigned int offset);
 
 
/*
 * FITS tools
 */

typedef struct {
  int fd;              
  unsigned int offset; 
  int bitPix;          
  int naxis1;          
  int naxis2;          
  int naxis3;          
  double bscale;       
  double bzero;        
} ngcb_cube_t;

char *ngcbFitsStrip(char *buffer, size_t *size, int *bitPix, char *erms);

int ngcbCube2Ext(const char *fileName, const char *extName, int numBlocks, 
         char *erms);

int ngcbSplitCube(const char *source, const char *target, int numBlocks, 
          char *erms);

int ngcbCubeOpen(const char *fileName, ngcb_cube_t *cube, char *erms);

int ngcbCubeRead(ngcb_cube_t cube, void *buffer, int slice, char *erms);

int ngcbCubeRead32(ngcb_cube_t cube, float *buffer, int slice, char *erms);

void ngcbCubeClose(ngcb_cube_t cube);
 

int ngcbKeyGetNext(char *fileBuffer, int fileLen, int *pos, int *line,
           const char *mask, char *key, char *keyVal, char *erms);

int ngcbKeySplit(char *key, int *nsplit, char **ksplit, int *val, 
         char *erms); 

int ngcbKeyIdx(char *key, int *nsplit, int *kval, char *erms);

int ngcbKeyMaskIdx(char *key, const char *mask);

int ngcbKeyGetVecInt(const char *keyVal, int *vec, char *erms);

int ngcbKeyGetVecFloat(const char *keyVal, float *vec, char *erms);

int ngcbKeyGetVecDouble(const char *keyVal, double *vec, char *erms);

void ngcbDiscardDetIdx(char *key);
 
#ifdef __cplusplus
}
#endif
 
#endif