pps-files.cpp

Go to the documentation of this file.

 
/*
 * Copyright (C) 2016-2020  Raymond S. Connell
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#include "../client/pps-client.h"
 
extern struct G g;
 
const char *config_file = "/XXXX/pps-client.conf";                              
const char *last_distrib_file = "/pps-error-distrib";                           
const char *distrib_file = "/pps-error-distrib-forming";                        
const char *last_jitter_distrib_file = "/pps-jitter-distrib";                   
const char *jitter_distrib_file = "/pps-jitter-distrib-forming";                
const char *log_file = "/pps-client.log";                                       
const char *old_log_file = "/pps-client.old.log";                               
const char *pidFilename = "/pps-client.pid";                                    
const char *assert_file = "/pps-assert";                                        
const char *displayParams_file = "/pps-display-params";                         
const char *arrayData_file = "/pps-save-data";                                  
const char *pps_msg_file = "/pps-msg";
const char *linuxVersion_file = "/linuxVersion";
const char *gmtTime_file = "/gmtTime";
const char *nistTime_file = "/nist_out";
const char *integral_state_file = "/.pps-last-state";
const char *home_file = "/Home";
const char *cpuinfo_file = "/cpuinfo";
 
const char *space = " ";
const char *num = "0123456789.";
 
extern const char *version;
 
static struct stat configFileStat;
static time_t modifyTime = 0;
static int lastJitterFileno = 0;
static int lastErrorFileno = 0;
static struct timespec offset_assert = {0, 0};
 
bool writeJitterDistrib = false;
bool writeErrorDistrib = false;
 
struct ppsFiles f;                                                      
 
const char *valid_config[] = {
        "error-distrib",
        "alert-pps-lost",
        "jitter-distrib",
        "exit-lost-pps",
        "pps-gpio",
        "output-gpio",
        "intrpt-gpio",
        "nist",
        "serial",
        "serialPort",
        "execdir",
        "servicedir",
        "configdir",
        "docdir",
        "rundir",
        "shmdir",
        "tstdir",
        "logdir",
        "zeroOffset",
        "moduledir",
        "ppsdevice",
        "ppsphase",
        "procdir",
        "segregate"
};
 
int List::binaryInsert(int val){
    if (count == size){
        return size;
    }
 
    count += 1;
 
    int high = ln - 1;
    if (ln == 0 || val > lst[high].val){
        insert(ln, val);
        return ln;
    }
    if (ln == 1){
        if (val < lst[0].val){
            insert(0, val);
            return 0;
        }
        if (val > lst[0].val){
            insert(ln, val);
            return ln;
        }
        lst[0].nVals += 1;
        return 0;
    }
    int low = -1;
    int j = 0;
    while ((high - low) > 1){
        j = (high + low) / 2;
        if (val <= lst[j].val){
            high = j;
        }
        else {
            low = j;
        }
    }
    if (lst[high].val == val){
        lst[high].nVals += 1;
        return high;
    }
    insert(high, val);
    return high;
}
 
 
double List::averageBelow(int maxVal){
 
    int sum = 0;
    int n = 0;
    double average;
 
    if (ln == 0){
        return 0;
    }
 
    for (int i = 0; i < ln; i++){
        sum += lst[i].nVals * lst[i].val;
        n += lst[i].nVals;
 
        if (i < ln-1){
            if (lst[i+1].val - lst[i].val >= maxVal){
                break;
            }
        }
    }
 
    average = (double)sum / (double)n;
 
    return average;
}
 
int sysCommand(const char *cmd){
    int rv = system(cmd);
    if (rv == -1 || WIFEXITED(rv) == false){
        sprintf(g.logbuf, "System command failed: %s\n", cmd);
        writeToLog(g.logbuf, "sysCommand()");
        return -1;
    }
    return 0;
}
 
char *getString(int key){
    char *str;
    int len;
    int i = round(log2(key));
 
    if (g.config_select & key){
 
        str = g.configVals[i];
 
        len = strlen(str);
 
        while (str[len-1] == ' '){
            str[len-1] = '\0';
            len -= 1;
        }
 
        return str;
    }
    return NULL;
}
 
bool hasString(int key, const char *string){
    int i = round(log2(key));
 
    if (g.config_select & key){
        char *val = strstr(g.configVals[i], string);
        if (val != NULL){
            return true;
        }
    }
    return false;
}
 
bool isEnabled(int key){
    return hasString(key, "enable");
}
 
bool isDisabled(int key){
    return hasString(key, "disable");
}
 
struct saveFileData arrayData[] = {
    {"rawError", g.rawErrorDistrib, "/var/local/pps-raw-error-distrib", ERROR_DISTRIB_LEN, 2, RAW_ERROR_ZERO},
    {"frequency-vars", NULL, "/var/local/pps-frequency-vars", 0, 3, 0},
    {"pps-offsets", NULL, "/var/local/pps-offsets", 0, 4, 0}
};
 
void couldNotOpenMsgTo(char *logbuf, const char *filename, const char* location){
    strcpy(logbuf, "ERROR: could not open \"");
    strcat(logbuf, filename);
    strcat(logbuf, "\": ");
    strcat(logbuf, strerror(errno));
    strcat(logbuf, " ");
    strcat(logbuf, location);
    strcat(logbuf, "\n");
}
 
void errorReadingMsgTo(char *logbuf, const char *filename){
    strcpy(logbuf, "ERROR: reading \"");
    strcat(logbuf, filename);
    strcat(logbuf, "\" was interrupted: ");
    strcat(logbuf, strerror(errno));
    strcat(logbuf, "\n");
}
 
void writeToLogNoTimestamp(char *logbuf){
    struct stat info;
 
    bufferStatusMsg(logbuf);
 
    stat(f.log_file, &info);
    if (info.st_size > 100000){         // Prevent unbounded log file growth
        remove(f.old_log_file);
        rename(f.log_file, f.old_log_file);
    }
 
    mode_t mode = S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH;
    int fd = open(f.log_file, O_CREAT | O_WRONLY | O_APPEND, mode);
    if (fd == -1){
        couldNotOpenMsgTo(logbuf, f.log_file, "writeToLogNoTimestamp()");
        printf("%s", logbuf);
        return;
    }
 
    int rv = write(fd, logbuf, strlen(logbuf));
    if (rv == -1){
        ;
    }
    close(fd);
}
 
 
void writeToLog(char *logbuf, const char *location){
    struct stat info;
 
    bufferStatusMsg(logbuf);
 
    stat(f.log_file, &info);
    if (info.st_size > 100000){         // Prevent unbounded log file growth
        remove(f.old_log_file);
        rename(f.log_file, f.old_log_file);
    }
 
    mode_t mode = S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH;
    int fd = open(f.log_file, O_CREAT | O_WRONLY | O_APPEND, mode);
    if (fd == -1){
        couldNotOpenMsgTo(logbuf, f.log_file, location);
        printf("%s", logbuf);
        return;
    }
 
    time_t t = time(NULL);
    struct tm *tmp = localtime(&t);
    strftime(g.strbuf, STRBUF_SZ-1, "%F %H:%M:%S ", tmp);
    int rv = write(fd, g.strbuf, strlen(g.strbuf));
    if (rv == -1){
        ;
    }
 
    rv = write(fd, logbuf, strlen(logbuf));
    if (rv == -1){
        ;
    }
    close(fd);
}
 
void bufferStatusMsg(const char *msg){
 
    if (g.isVerbose){
        fprintf(stdout, "%s", msg);
    }
 
    int msglen = strlen(g.savebuf) + 10;
    int parmslen = strlen(msg);
 
    if (msglen + parmslen > MSGBUF_SZ){
        return;
    }
 
    strcat(g.savebuf, msg);
 
    return;
}
 
int writeStatusStrings(void){
 
    int fSize = strlen(g.savebuf);
 
    remove(f.displayParams_file);
    int fd = open_logerr(f.displayParams_file, O_CREAT | O_WRONLY, "writeStatusStrings() 1");
    if (fd == -1){
        return -1;
    }
    int rv = write(fd, g.savebuf, fSize);
    close(fd);
    if (rv == -1){
        sprintf(g.logbuf, "writeStatusStrings() Could not write to %s. Error: %s\n", f.displayParams_file, strerror(errno));
        writeToLog(g.logbuf, "writeStatusStrings() 2");
        return -1;
    }
 
    g.savebuf[0] = '\0';
    return 0;
}
 
int read_logerr(int fd, char *buf, int sz, const char *filename){
    int rv = read(fd, buf, sz);
    if (rv == -1){
        errorReadingMsgTo(g.logbuf, filename);
        writeToLog(g.logbuf, "read_logerr()");
        return rv;
    }
    return rv;
}
 
int open_logerr(const char* filename, int flags, const char *location){
    int mode = S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH;
    int fd;
    if ((flags & O_CREAT) == O_CREAT){
        fd = open(filename, flags, mode);
    }
    else {
        fd = open(filename, flags);
    }
    if (fd == -1){
        couldNotOpenMsgTo(g.logbuf, filename, location);
        writeToLog(g.logbuf, location);
        return -1;
    }
    return fd;
}
 
int saveLastState(void){
    char buf[500];
 
    int fd = open_logerr(f.integral_state_file, O_CREAT | O_WRONLY, "saveLastState()");
    if (fd == -1){
        return -1;
    }
 
    memset(buf, 0, 500 * sizeof(char));
    char *pbuf;
    pbuf = buf;
    for (int i = 0; i < NUM_INTEGRALS; i++){
        sprintf(pbuf, "%lf\n", g.integral[i]);
        while (*pbuf != '\0'){
            pbuf += 1;
        }
    }
 
    sprintf(pbuf, "%d\n", g.slewIsLow);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%lf\n", g.avgIntegral);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%d\n", g.integralCount);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%d\n", g.correctionFifo_idx);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%lf\n", g.integralTimeCorrection);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    for (int i = 0; i < OFFSETFIFO_LEN; i++){
        sprintf(pbuf, "%d\n", g.correctionFifo[i]);
        while (*pbuf != '\0'){
            pbuf += 1;
        }
    }
 
    sprintf(pbuf, "%d\n", g.correctionFifoCount);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%d\n", g.correctionAccum);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%lf\n", g.freqOffset);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%d\n", g.activeCount);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%d\n", g.seq_num);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%d\n", (int)g.isControlling);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    sprintf(pbuf, "%d\n", g.hardLimit);
    while (*pbuf != '\0'){
        pbuf += 1;
    }
 
    int rv = write(fd, buf, strlen(buf) + 1);
 
    close(fd);
 
    if (rv == -1){
        sprintf(g.logbuf, "saveLastState() Write to %s failed\n", integral_state_file);
        writeToLog(g.logbuf, "daemonSaveArray()");
        return -1;
    }
    return 0;
}
 
int loadLastState(void){
    char buf[500];
 
    int fd = open(f.integral_state_file, O_RDONLY);
    if (fd == -1){
        return 1;
    }
 
    int rv = read_logerr(fd, buf, 499, integral_state_file);
    if (rv == -1){
        return -1;
    }
    close(fd);
 
    char *pbuf = buf;
 
    for (int i = 0; i < NUM_INTEGRALS; i++){
        sscanf(pbuf, "%lf\n", &g.integral[i]);
 
        while (*pbuf != '\n'){
            pbuf += 1;
        }
        pbuf += 1;
    }
 
    int b;
    sscanf(pbuf, "%d\n", &b);
    g.slewIsLow = false;
    if (b > 0){
        g.slewIsLow = true;
    }
 
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    sscanf(pbuf, "%lf\n", &g.avgIntegral);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    sscanf(pbuf, "%d\n", &g.integralCount);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    sscanf(pbuf, "%d\n", &g.correctionFifo_idx);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    sscanf(pbuf, "%lf\n", &g.integralTimeCorrection);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    for (int i = 0; i < OFFSETFIFO_LEN; i++){
        sscanf(pbuf, "%d\n", &g.correctionFifo[i]);
 
        while (*pbuf != '\n'){
            pbuf += 1;
        }
        pbuf += 1;
    }
 
    sscanf(pbuf, "%d\n", &g.correctionFifoCount);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    sscanf(pbuf, "%d\n", &g.correctionAccum);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    sscanf(pbuf, "%lf\n", &g.freqOffset);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    sscanf(pbuf, "%d\n", &g.activeCount);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    sscanf(pbuf, "%d\n", &g.seq_num);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    int t_f;
    sscanf(pbuf, "%d\n", &t_f);
    if (t_f == 0){
        g.isControlling = false;
    }
    else {
        g.isControlling = true;
    }
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    sscanf(pbuf, "%d\n", &g.hardLimit);
    while (*pbuf != '\n'){
        pbuf += 1;
    }
    pbuf += 1;
 
    g.startingFromRestore = SECS_PER_MINUTE;
 
    g.freqOffset = g.integralTimeCorrection * g.integralGain;
 
    g.t3.modes = ADJ_FREQUENCY;
    g.t3.freq = (long)round(ADJTIMEX_SCALE * g.freqOffset);
    adjtimex(&g.t3);                            // Adjust the system clock frequency.
 
    return 0;
}
 
int writeFileMsgToLogbuf(const char *filename, char *logbuf){
    struct stat stat_buf;
    int rv;
 
    int fd = open(filename, O_RDONLY);
    if (fd == -1){
        couldNotOpenMsgTo(logbuf, filename, "writeFileMsgToLogbuf()");
        printf("%s", logbuf);
        return -1;
    }
    fstat(fd, &stat_buf);
    int sz = stat_buf.st_size;
 
    if (sz >= LOGBUF_SZ-1){
        rv = read(fd, logbuf, LOGBUF_SZ-1);
        if (rv == -1){
            errorReadingMsgTo(logbuf, filename);
            printf("%s", logbuf);
            return rv;
        }
        logbuf[LOGBUF_SZ-1] = '\0';
    }
    else {
        rv = read(fd, logbuf, sz);
        if (rv == -1){
            errorReadingMsgTo(logbuf, filename);
            printf("%s", logbuf);
            return rv;
        }
        logbuf[sz] = '\0';
    }
    close(fd);
    remove(filename);
 
    return 0;
}
 
int writeFileMsgToLog(const char *filename){
    return writeFileMsgToLogbuf(filename, g.logbuf);
}
 
pid_t getChildPID(void){
    pid_t pid = 0;
 
    memset(g.strbuf, 0, STRBUF_SZ-1);
 
    int pfd = open_logerr(f.pidFilename, O_RDONLY, "getChildPID()");
    if (pfd == -1){
        return -1;
    }
    if (read_logerr(pfd, g.strbuf, 19, f.pidFilename) == -1){
        close(pfd);
        return -1;
    }
    sscanf(g.strbuf, "%d\n", &pid);
    close(pfd);
    if (pid > 0){
        return pid;
    }
    return -1;
}
 
bool ppsIsRunning(void){
    char buf[50];
    char cmdbuf[100];
 
    memset(cmdbuf, 0, 100 * sizeof(char));
    strcpy(cmdbuf, "pidof pps-client > ");
    strcat(cmdbuf, f.pps_msg_file);
 
    int rv = sysCommand(cmdbuf);
    if (rv == -1){
        return false;
    }
 
    int fd = open(f.pps_msg_file, O_RDONLY);
    if (fd == -1){
        sprintf(g.logbuf, "ppsIsRunning() Failed. Could not open %s. Error: %s\n", f.pps_msg_file, strerror(errno));
        writeToLog(g.logbuf, "ppsIsRunning()");
        return false;
    }
    memset(buf, 0, 50 * sizeof(char));
    rv = read(fd, buf, 50);
    if (rv == -1){
        sprintf(g.logbuf, "ppsIsRunning() Failed. Could not read %s. Error: %s\n", f.pps_msg_file, strerror(errno));
        writeToLog(g.logbuf, "ppsIsRunning()");
        return false;
    }
 
    int callerPID = 0, daemonPID = 0;                   // If running both of these exist
    sscanf(buf, "%d %d\n", &callerPID, &daemonPID);
 
    close(fd);
    remove(f.pps_msg_file);
 
    if (daemonPID == 0){                                    // Otherwise only the first exists.
        return false;
    }
    return true;
}
 
int createPIDfile(void){
 
    struct stat buf;
    int rv = stat(f.pidFilename, &buf);
    if (rv == 0){                           // If the PID file exists from previously,
        rv = remove(f.pidFilename);         // then remove it.
        if (rv != 0){
            return -1;
        }
    }
 
    int pfd = open_logerr(f.pidFilename, O_RDWR | O_CREAT | O_EXCL, "createPIDfile()");
    if (pfd == -1){
        return -1;
    }
 
    pid_t ppid = getpid();
 
    sprintf(g.strbuf, "%d\n", ppid);
    if (write(pfd, g.strbuf, strlen(g.strbuf)) == -1)   // Try to write the PID
    {
        close(pfd);
        sprintf(g.logbuf, "createPIDfile() Could not write a PID file. Error: %s\n", strerror(errno));
        writeToLog(g.logbuf, "createPIDfile()");
        return -1;                                  // Write failed.
    }
    close(pfd);
 
    return ppid;
}
 
int readConfigFile(const char *fconfig){
 
    struct stat stat_buf;
 
    int rvs = stat(fconfig, &configFileStat);
    if (rvs == -1){
        sprintf(g.logbuf, "readConfigFile(): Config file not found.\n");
        writeToLog(g.logbuf, "readConfigFile()");
        return -1;                                  // No config file
    }
 
    timespec t = configFileStat.st_mtim;
 
    if (g.configWasRead && g.seq_num > 0 && modifyTime == t.tv_sec){
        return 1;                                   // Config file unchanged from last read
    }
 
    modifyTime = t.tv_sec;
 
    int fd = open_logerr(fconfig, O_RDONLY, "readConfigFile()");
    if (fd == -1){
        return -1;
    }
 
    fstat(fd, &stat_buf);
    int sz = stat_buf.st_size;
 
    if (sz >= CONFIG_FILE_SZ){
        sprintf(g.logbuf, "readConfigFile(): not enough space allocated for config file.\n");
        writeToLog(g.logbuf, "readConfigFile()");
        return -1;
    }
 
    int rv = read_logerr(fd, g.configBuf, sz, fconfig);
    if (rv == -1 || sz != rv){
        return -1;
    }
    close(fd);
 
    g.configBuf[sz] = '\0';
 
    int nCfgStrs = 0;
    int i;
 
    char *pToken = strtok(g.configBuf, "\n");           // Separate tokens at "\n".
 
    while (pToken != NULL){
        if (strlen(pToken) != 0){                       // If not a blank line.
            for (int j = 0; j < 10; j++){               // Skip leading spaces.
                if (pToken[0] == ' '){
                    pToken += 1;
                }
                else {
                    break;                              // Break on first non-space character.
                }
            }
 
            if (pToken[0] != '#'){                      // Ignore comment lines.
                g.configVals[nCfgStrs] = pToken;
                nCfgStrs += 1;
            }
        }
        pToken = strtok(NULL, "\n");                    // Get the next token.
    }
 
    if (nCfgStrs == 0){
        return 0;
    }
 
    for (i = 0; i < nCfgStrs; i++){                     // Compact g.configBuf to remove string terminators inserted by
        if (i == 0){                                    // strtok() so that g.configBuf can be searched as a single string.
            strcpy(g.configBuf, g.configVals[i]);
        }
        else {
            strcat(g.configBuf, g.configVals[i]);
        }
        strcat(g.configBuf, "\n");
    }
 
    int nValidCnfgs = sizeof(valid_config) / sizeof(char *);
 
    char **configVal = g.configVals;                    // Use g.configVals to return pointers to value strings
    char *value;
 
    for (i = 0; i < nValidCnfgs; i++){
 
        char *found = strstr(g.configBuf, valid_config[i]);
        if (found != NULL){
            g.config_select |= 1 << i;                  // Set a bit in g.config_select
 
            value = strpbrk(found, "=");                // Get the value string following '='.
            value += 1;
 
            configVal[i] = value;                       // Point to g.configVals[i] value string in g.configBuf
        }
        else {
            g.config_select &= ~(1 << i);               // Clear a bit in config_select
            configVal[i] = NULL;
        }
    }
 
    for (i = 0; i < nValidCnfgs; i++){                  // Replace the "\n" at the end of each value
        if (configVal[i] != NULL){                      // string with a string terminator.
            value = strpbrk(configVal[i], "\n");
            if (value != NULL){
                *value = 0;
            }
        }
    }
 
    if (g.seq_num > 0){
        g.configWasRead = true;                         // Insures that config file read at least once.
    }
 
    return 0;
}
 
void writeDistribution(int distrib[], int len, int scaleZero, int count,
        int *last_epoch, const char *distrib_file, const char *last_distrib_file){
    int rv = 0;
    remove(distrib_file);
    int fd = open_logerr(distrib_file, O_CREAT | O_WRONLY | O_APPEND, "writeDistribution()");
    if (fd == -1){
        return;
    }
    for (int i = 0; i < len; i++){
        sprintf(g.strbuf, "%d %d\n", i-scaleZero, distrib[i]);
        rv = write(fd, g.strbuf, strlen(g.strbuf));
        if (rv == -1){
            sprintf(g.logbuf, "writeDistribution() Unable to write to %s. Error: %s\n", distrib_file, strerror(errno));
            writeToLog(g.logbuf, "writeDistribution()");
            close(fd);
            return;
        }
    }
    close(fd);
 
    int epoch = count / SECS_PER_DAY;
    if (epoch != *last_epoch ){
        *last_epoch = epoch;
        remove(last_distrib_file);
        rename(distrib_file, last_distrib_file);
        memset(distrib, 0, len * sizeof(int));
    }
}
 
void writeJitterDistribFile(void){
    if (g.jitterCount % SECS_PER_MINUTE == 0 && g.seq_num > SETTLE_TIME){
        int scaleZero = JITTER_DISTRIB_LEN / 3;
        writeDistribution(g.jitterDistrib, JITTER_DISTRIB_LEN, scaleZero, g.jitterCount,
                &lastJitterFileno, f.jitter_distrib_file, f.last_jitter_distrib_file);
    }
}
 
void writeErrorDistribFile(void){
    if (g.errorCount % SECS_PER_MINUTE == 0 && g.seq_num > SETTLE_TIME){
        int scaleZero = ERROR_DISTRIB_LEN / 6;
        writeDistribution(g.errorDistrib, ERROR_DISTRIB_LEN, scaleZero,
                g.errorCount, &lastErrorFileno, f.distrib_file, f.last_distrib_file);
    }
}
 
void writeOffsets(const char *filename){
    int fd = open_logerr(filename, O_CREAT | O_WRONLY | O_TRUNC, "writeOffsets()");
    if (fd == -1){
        return;
    }
    for (int i = 0; i < SECS_PER_10_MIN; i++){
        int j = g.recIndex2 + i;
        if (j >= SECS_PER_10_MIN){
            j -= SECS_PER_10_MIN;
        }
        sprintf(g.strbuf, "%d %d %lf\n", g.seq_numRec[j], g.offsetRec[j], g.freqOffsetRec2[j]);
        int rv = write(fd, g.strbuf, strlen(g.strbuf));
        if (rv == -1){
            sprintf(g.logbuf, "writeOffsets() Unable to write to %s. Error: %s\n", filename, strerror(errno));
            writeToLog(g.logbuf, "writeOffsets()");
        }
    }
    close(fd);
}
 
void writeFrequencyVars(const char *filename){
    int fd = open_logerr(filename, O_CREAT | O_WRONLY | O_TRUNC, "writeFrequencyVars()");
    if (fd == -1){
        return;
    }
    for (int i = 0; i < NUM_5_MIN_INTERVALS; i++){
        int j = g.recIndex + i;                         // Read the circular buffers relative to g.recIndx.
        if (j >= NUM_5_MIN_INTERVALS){
            j -= NUM_5_MIN_INTERVALS;
        }
        sprintf(g.strbuf, "%ld %lf %lf\n", g.timestampRec[j], g.freqOffsetRec[j], g.freqAllanDev[j]);
        int rv = write(fd, g.strbuf, strlen(g.strbuf));
        if (rv == -1){
            sprintf(g.logbuf, "writeFrequencyVars() Write to %s failed with error: %s\n", filename, strerror(errno));
            writeToLog(g.logbuf, "writeFrequencyVars");
            close(fd);
            return;
        }
    }
    close(fd);
}
 
int saveDoubleArray(double distrib[], const char *filename, int len, int arrayZero){
 
    int fd = open_logerr(filename, O_CREAT | O_WRONLY | O_TRUNC, "saveDoubleArray()");
    if (fd == -1){
        return -1;
    }
 
    int fileMaxLen = len * MAX_LINE_LEN * sizeof(char);
    char *filebuf = new char[fileMaxLen];
    int fileLen = 0;
 
    filebuf[0] = '\0';
    for (int i = 0; i < len; i++){
        sprintf(g.strbuf, "%d %7.2lf\n", i - arrayZero, distrib[i]);
        fileLen += strlen(g.strbuf);
        strcat(filebuf, g.strbuf);
    }
 
    int rv = write(fd, filebuf, fileLen + 1);
    if (rv == -1){
        sprintf(g.logbuf, "saveDoubleArray() Write to %s failed with error: %s\n", filename, strerror(errno));
        writeToLog(g.logbuf, "saveDoubleArray()");
        return -1;
    }
 
    fsync(fd);
 
    delete[] filebuf;
    close(fd);
    return 0;
}
 
int processWriteRequest(void){
    struct stat buf;
 
    int rv = stat(f.arrayData_file, &buf);          // stat() used only to check that there is an arrayData_file
    if (rv == -1){
        return 0;
    }
 
    int fd = open(f.arrayData_file, O_RDONLY);
    if (fd == -1){
        sprintf(g.logbuf, "processWriteRequest() Unable to open %s. Error: %s\n", f.arrayData_file, strerror(errno));
        writeToLog(g.logbuf, "processWriteRequest()");
        return -1;
    }
 
    char requestStr[25];
    char filename[225];
 
    filename[0] = '\0';
    rv = read(fd, g.strbuf, STRBUF_SZ-1);
    sscanf(g.strbuf, "%s %s", requestStr, filename);
 
    close(fd);
    remove(f.arrayData_file);
 
    int arrayLen = sizeof(arrayData) / sizeof(struct saveFileData);
    for (int i = 0; i < arrayLen; i++){
        if (strcmp(requestStr, arrayData[i].label) == 0){
            if (strlen(filename) == 0){
                strcpy(filename, arrayData[i].filename);
            }
            if (arrayData[i].arrayType == 2){
                saveDoubleArray((double *)arrayData[i].array, filename, arrayData[i].arrayLen, arrayData[i].arrayZero);
                break;
            }
            if (arrayData[i].arrayType == 3){
                writeFrequencyVars(filename);
                break;
            }
            if (arrayData[i].arrayType == 4){
                writeOffsets(filename);
                break;
            }
 
        }
    }
    return 0;
}
 
int getSharedConfigs(void){
 
    int rv = readConfigFile(config_file);
    if (rv == -1){
        return rv;
    }
 
    char *sp;
 
    sp = getString(RUNDIR);
    if (sp != NULL){
        strcpy(f.pidFilename, sp);
        strcat(f.pidFilename, pidFilename);
    }
 
    sp = getString(SHMDIR);
    if (sp != NULL){
        strcpy(f.assert_file, sp);
        strcat(f.assert_file, assert_file);
 
        strcpy(f.displayParams_file, sp);
        strcat(f.displayParams_file, displayParams_file);
 
        strcpy(f.arrayData_file, sp);
        strcat(f.arrayData_file, arrayData_file);
 
        strcpy(f.pps_msg_file, sp);
        strcat(f.pps_msg_file, pps_msg_file);
    }
 
    sp = getString(TSTDIR);
    if (sp != NULL){
        strcpy(f.last_distrib_file, sp);
        strcat(f.last_distrib_file, last_distrib_file);
 
        strcpy(f.distrib_file, sp);
        strcat(f.distrib_file, distrib_file);
 
        strcpy(f.last_jitter_distrib_file, sp);
        strcat(f.last_jitter_distrib_file, last_jitter_distrib_file);
 
        strcpy(f.home_file, sp);
        strcat(f.home_file, home_file);
    }
 
    sp = getString(LOGDIR);
    if (sp != NULL){
        strcpy(f.log_file, sp);
        strcat(f.log_file, log_file);
 
        strcpy(f.old_log_file, sp);
        strcat(f.old_log_file, old_log_file);
    }
 
    g.doNISTsettime = true;
 
    if (isEnabled(SERIAL)){
        g.doNISTsettime = false;
        g.doSerialsettime = true;
    }
    else if (isDisabled(SERIAL)){
        g.doSerialsettime = false;
    }
 
    sp = getString(SERIAL_PORT);
    if (sp != NULL){
        strcpy(g.serialPort, sp);
    }
 
    if (isEnabled(NIST)){
        g.doNISTsettime = true;
    }
    else if (isDisabled(NIST)){
        g.doNISTsettime = false;
    }
 
    return 0;
}
 
int getConfigs(void){
 
    // Activities that are checked each second ******************
 
    if (isEnabled(ERROR_DISTRIB)){
        if (writeErrorDistrib == false){
            memset(g.errorDistrib, 0, ERROR_DISTRIB_LEN * sizeof(int));
            g.errorCount = 0;
            writeErrorDistrib = true;
        }
    }
    else {
        writeErrorDistrib = false;
    }
 
    if (writeErrorDistrib){
        writeErrorDistribFile();
    }
 
    if (isEnabled(JITTER_DISTRIB)){
        if (writeJitterDistrib == false){
            memset(g.jitterDistrib, 0, JITTER_DISTRIB_LEN * sizeof(int));
            g.jitterCount = 0;
            writeJitterDistrib = true;
        }
    }
    else {
        writeJitterDistrib = false;
    }
 
    if (writeJitterDistrib){
        writeJitterDistribFile();
    }
 
    int rv = processWriteRequest();
    if (rv == -1){
        return rv;
    }
 
    //****************************************************************
 
    rv = readConfigFile(config_file);
    if (rv == -1){
        return rv;
    }
    if (rv == 1){                       // Skip reading again if rv == 1
        return 0;
    }
 
    char *sp;
    struct stat dirStat;
 
    sp = getString(RUNDIR);
    if (sp != NULL){
 
        rv = stat(sp, &dirStat);
        if (rv == -1){
            printf("Invalid path for rundir. %s: %s\n", strerror(errno), sp);
            return rv;
        }
 
        strcpy(f.pidFilename, sp);
        strcat(f.pidFilename, pidFilename);
    }
 
    sp = getString(SHMDIR);
    if (sp != NULL){
 
        rv = stat(sp, &dirStat);
        if (rv == -1){
            printf("Invalid path for shmdir in pps-client.conf. %s: %s\n", strerror(errno), sp);
            return rv;
        }
 
        strcpy(f.assert_file, sp);
        strcat(f.assert_file, assert_file);
 
        strcpy(f.displayParams_file, sp);
        strcat(f.displayParams_file, displayParams_file);
 
        strcpy(f.arrayData_file, sp);
        strcat(f.arrayData_file, arrayData_file);
 
        strcpy(f.pps_msg_file, sp);
        strcat(f.pps_msg_file, pps_msg_file);
 
        strcpy(f.linuxVersion_file, sp);
        strcat(f.linuxVersion_file, linuxVersion_file);
 
        strcpy(f.gmtTime_file, sp);
        strcat(f.gmtTime_file, gmtTime_file);
 
        strcpy(f.nistTime_file, sp);
        strcat(f.nistTime_file, nistTime_file);
    }
 
    sp = getString(TSTDIR);
    if (sp != NULL){
 
        rv = stat(sp, &dirStat);
        if (rv == -1){
            printf("Invalid path for tstdir in pps-client.conf. %s: %s\n", strerror(errno), sp);
            return rv;
        }
 
        strcpy(f.last_distrib_file, sp);
        strcat(f.last_distrib_file, last_distrib_file);
 
        strcpy(f.distrib_file, sp);
        strcat(f.distrib_file, distrib_file);
 
        strcpy(f.last_jitter_distrib_file, sp);
        strcat(f.last_jitter_distrib_file, last_jitter_distrib_file);
 
        strcpy(f.jitter_distrib_file, sp);
        strcat(f.jitter_distrib_file, jitter_distrib_file);
 
        strcpy(f.home_file, sp);
        strcat(f.home_file, home_file);
    }
 
    sp = getString(LOGDIR);
    if (sp != NULL){
 
        rv = stat(sp, &dirStat);
        if (rv == -1){
            printf("Invalid path for logdir in pps-client.conf. %s: %s\n", strerror(errno), sp);
            return rv;
        }
 
        strcpy(f.log_file, sp);
        strcat(f.log_file, log_file);
 
        strcpy(f.old_log_file, sp);
        strcat(f.old_log_file, old_log_file);
    }
 
    sp = getString(PPSDEVICE);
    if (sp != NULL){
 
        rv = stat(sp, &dirStat);
        if (rv == -1){
            printf("Invalid path for ppsdevice in pps-client.conf. %s: %s\n", strerror(errno), sp);
            return rv;
        }
 
        strcpy(f.pps_device, sp);
    }
 
    sp = getString(PPSDELAY);
    if (sp != NULL){
        char *ptr;
        g.zeroOffset = (int)strtol(sp, &ptr, 10);
    }
 
    sp = getString(SEGREGATE);
    if (sp != NULL){
        rv = sscanf(sp, "%d/%d", &g.useCore, &g.nCores);
        if (rv != 2 || g.useCore >= g.nCores){
            printf("Invalid value for segregate in pps-client.conf\n");
            return -1;
        }
    }
 
    sp = getString(PPSPHASE);
    if (sp != NULL){
        char *ptr;
        g.ppsPhase = (int)strtol(sp, &ptr, 10);
        if(g.ppsPhase > 1){
            printf("Invalid value for ppsphase in pps-client.conf. Must be 0 or 1.\n");
            return -1;
        }
    }
 
    sp = getString(PROCDIR);
    if (sp != NULL){
 
        rv = stat(sp, &dirStat);
        if (rv == -1){
            printf("Invalid path for procdir in pps-client.conf. %s: %s\n", strerror(errno), sp);
            return rv;
        }
 
        strcpy(f.cpuinfo_file, sp);
        strcat(f.cpuinfo_file, cpuinfo_file);
    }
 
    g.doNISTsettime = true;
 
    if (isEnabled(NIST)){
        g.doNISTsettime = true;
    }
    else if (isDisabled(NIST)){
        g.doNISTsettime = false;
    }
 
    if (isEnabled(SERIAL)){
        g.doNISTsettime = false;
        g.doSerialsettime = true;
    }
    else if (isDisabled(SERIAL)){
        g.doSerialsettime = false;
    }
 
    sp = getString(SERIAL_PORT);
    if (sp != NULL){
        strcpy(g.serialPort, sp);
    }
 
    if (isEnabled(EXIT_LOST_PPS)){
        g.exitOnLostPPS = true;
    }
    else if (isDisabled(EXIT_LOST_PPS)){
        g.exitOnLostPPS = false;
    }
 
    return 0;
}
 
void writeTimestamp(double timestamp){
    memset(g.strbuf, 0, STRBUF_SZ-1);
 
    sprintf(g.strbuf, "%lf#%d\n", timestamp, g.seq_num);
    remove(f.assert_file);
 
    int pfd = open_logerr(f.assert_file, O_CREAT | O_WRONLY, "writeTimestamp() 1");
    if (pfd == -1){
        return;
    }
    int rv = write(pfd, g.strbuf, strlen(g.strbuf) + 1);        // Write PPS timestamp to f.assert_file
    if (rv == -1){
        sprintf(g.logbuf, "writeTimestamp() write to assert_file failed with error: %s\n", strerror(errno));
        writeToLog(g.logbuf, "writeTimestamp() 2");
    }
    close(pfd);
}
 
int alignNumbersAfter(const char *token, char *buf, int len){
    int pos = 0;
 
    char *str = strstr(buf, token);
    if (str == NULL){
        sprintf(g.logbuf, "alignNumbersAfter(): token not found. Exiting.\n");
        writeToLog(g.logbuf, "alignNumbersAfter()");
        return -1;
    }
    str += strlen(token);
 
    pos = str - buf;
    if (buf[pos] != '-'){
        memmove(str + 1, str, len - pos);
        buf[pos] = ' ';
        len += 1;
    }
    return len;
}
 
int alignTokens(const char *refToken, int offset, const char *token, char *buf, int len){
 
    int pos1, pos2;
 
    char *str = strstr(buf, refToken);
    if (str == NULL){
        sprintf(g.logbuf, "alignTokens(): refToken not found. Exiting.\n");
        writeToLog(g.logbuf, "alignTokens()");
        return -1;
    }
    str += strlen(refToken);
    pos1 = str - buf;
 
    str = strstr(buf, token);
    if (str == NULL){
        sprintf(g.logbuf, "alignTokens(): token not found. Exiting.\n");
        writeToLog(g.logbuf, "alignTokens()");
        return -1;
    }
    pos2 = str - buf;
 
    while (pos2 < pos1 + offset){
        memmove(str + 1, str, len - pos2);
        buf[pos2] = ' ';
        pos2 += 1;
        str += 1;
        len += 1;
    }
    return len;
}
 
int bufferStateParams(void){
 
    if (g.interruptLossCount == 0) {
        const char *timefmt = "%F %H:%M:%S";
        char timeStr[50];
        char printStr[200];
 
        memset(timeStr, 0, 50 * sizeof(char));
        strftime(timeStr, 50, timefmt, localtime(&g.pps_t_sec));
 
        char *printfmt = g.strbuf;
 
        strcpy(printfmt, "%s.%06d  %d  jitter: ");
 
        if (g.clampAbsolute){
            strcat(printfmt, "%d freqOffset: %f avgCorrection: %f  clamp: %d\n");
        }
        else {
            strcat(printfmt, "%d freqOffset: %f avgCorrection: %f  clamp: %d*\n");
        }
 
        sprintf(printStr, printfmt, timeStr, g.pps_t_usec, g.seq_num,
                g.jitter, g.freqOffset, g.avgCorrection, g.hardLimit);
 
        int len = strlen(printStr) + 1;                         // strlen + '\0'
        len = alignNumbersAfter("jitter: ", printStr, len);
        if (len == -1){
            return -1;
        }
        len = alignTokens("jitter:", 6, "freqOffset:", printStr, len);
        if (len == -1){
            return -1;
        }
        len = alignNumbersAfter("freqOffset:", printStr, len);
        if (len == -1){
            return -1;
        }
        len = alignTokens("freqOffset:", 12, "avgCorrection:", printStr, len);
        if (len == -1){
            return -1;
        }
        len = alignNumbersAfter("avgCorrection: ", printStr, len);
        if (len == -1){
            return -1;
        }
        len = alignTokens("avgCorrection:", 12, "clamp:", printStr, len);
        if (len == -1){
            return -1;
        }
 
        bufferStatusMsg(printStr);
    }
    return 0;
}
 
void removeConfigKeys(const char *key1, const char *key2, char *fbuf){
 
    char *pHead = NULL, *pTail = NULL, *pNxt = NULL;
    char *pLine = NULL;
 
    pLine = fbuf;
 
    while (strlen(pLine) > 0){
                                        // Search for key1 followed by key2
        while (pLine != NULL){                                      // If this is the next line
 
            pNxt = pLine;
            while (pNxt[0] == ' ' || pNxt[0] == '\t'){
                pNxt += 1;
            }
 
            if (strncmp(pNxt, key1, strlen(key1)) == 0){
                pHead = pNxt;
                pNxt += strlen(key1);
 
                while (pNxt[0] == ' ' || pNxt[0] == '\t'){
                    pNxt += 1;
                }
 
                if (strncmp(pNxt, key2, strlen(key2)) == 0){
                    pNxt += strlen(key2);
 
                    while (pNxt[0] == ' ' || pNxt[0] == '\t' ||  pNxt[0] == '\n'){
                        pNxt += 1;
                    }
                    pTail = pNxt;
 
                    memmove(pHead, pTail, strlen(pTail)+1);
                    pLine = pHead;                              // Point pLine to any remaining
                    break;                                      // tail of the file for removal
                }                                               // of any more lines containing
            }                                                   // "key1 key2".
            pLine = strchr(pLine, '\n') + 1;
        }
    }
}
 
char *getLinuxVersion(void){
    int rv;
    char fbuf[20];
    char cmdbuf[100];
 
    memset(cmdbuf, 0, 100 * sizeof(char));
    strcpy(cmdbuf, "uname -r > ");
    strcat(cmdbuf, f.linuxVersion_file);
 
    rv = sysCommand(cmdbuf);
    if (rv == -1){
        return NULL;
    }
 
    int fd = open(f.linuxVersion_file, O_RDONLY);
    rv = read(fd, fbuf, 20);
    if (rv == -1){
        sprintf(g.logbuf, "getLinuxVersion(): Unable to read Linux version from %s\n", f.linuxVersion_file);
        writeToLog(g.logbuf, "getLinuxVersion()");
        return NULL;
    }
    sscanf(fbuf, "%s\n", g.linuxVersion);
    return g.linuxVersion;
}
 
 
int getRPiCPU(void){
    int rv;
 
    int fd = open_logerr(f.cpuinfo_file, O_RDONLY, "getRPiCPU()");
    if (fd == -1){
        printf("getRPiCPU() Open f.cpuinfo_file failed\n");
        return -1;
    }
 
    char *filebuf = new char[CONFIG_FILE_SZ];
    memset(filebuf, 0, CONFIG_FILE_SZ * sizeof(char));
 
    rv = read(fd, filebuf, CONFIG_FILE_SZ-1);
    if (rv == -1){
        sprintf(g.logbuf, "getRPiCPU(): Unable to read from %s\n", f.cpuinfo_file);
        writeToLog(g.logbuf, "getRPiCPU()");
        delete filebuf;
        return -1;
    }
 
    rv = 0;
 
    char *pstr = strstr(filebuf, "Raspberry Pi");
    if (pstr != NULL){
        if (strncmp(pstr, "Raspberry Pi 3", 14) == 0){
            rv = 3;
        }
        else if (strncmp(pstr, "Raspberry Pi 4", 14) == 0){
            rv = 4;
        }
    }
    delete filebuf;
    return rv;
}
 
int assignProcessorAffinity(void){
    int rv;
    char cmdstr[100];
    char cmd[100];
    int bitmask = 0;
    struct stat stat_buf;
 
    sprintf(cmdstr, "printf 'Assigned PPS-Client to processor %d\n'", g.useCore);
    sysCommand(cmdstr);
 
    for (int i = g.nCores - 1; i >= 0; i--){                        // Create bitmask of cores to be used
        bitmask = bitmask << 1;                                     // by all processes except PPS-Client
        if (g.useCore != i){
            bitmask |= 1;
        }
    }
 
    memset(cmd, 0, 100);
    sprintf(cmd,"taskset -p %d ", bitmask);
 
    const char *end = " > /dev/null 2>&1";                          // "> /dev/null 2>&1" suppresses all messages
 
    rv = sysCommand("ps --no-headers -eo pid > /dev/shm/pid.txt");  // Save PIDs only of all running processes
    if (rv == -1){
        return rv;
    }
 
 
    int fd = open("/dev/shm/pid.txt", O_RDONLY);                    // Open the PID file
    if (fd == -1){
        return fd;
    }
 
    fstat(fd, &stat_buf);
    int sz = stat_buf.st_size;
 
    char *fbuf = new char[sz+1];
 
    rv = read(fd, fbuf, sz);                                        // Read PID file into fbuf
 
    close(fd);
 
    if (rv == -1){
        delete fbuf;
        return rv;
    }
 
    char *pbuf = strtok(fbuf, "\n");                                // Locate the first CR
 
    pbuf = strtok(NULL, "\n\0");
    memset(cmdstr, 0, 100);
    strcpy(cmdstr, cmd);
    strcat(cmdstr, fbuf);
    strcat(cmdstr, end);
 
    rv = sysCommand(cmdstr);
    if (rv == -1){
        delete fbuf;
        return rv;
    }
 
    while (pbuf != NULL){
        pbuf = strtok(NULL, "\n\0");
        if (pbuf != NULL){
 
            memset(cmdstr, 0, 100);
            strcpy(cmdstr, cmd);
            strcat(cmdstr, pbuf);
            strcat(cmdstr, end);
 
            rv = sysCommand(cmdstr);                // Attempt to put each running processes on other cores
            if (rv == -1){
                delete fbuf;
                return rv;
            }
 
        }
    }
 
    bitmask = 0;
 
    for (int i = g.nCores - 1; i >= 0; i--){        // Create bitmask of core to be used
        bitmask = bitmask << 1;                     // by PPS-Client
        if (g.useCore == i){
            bitmask |= 1;
        }
    }
 
    memset(cmdstr, 0, 100);
    sprintf(cmdstr,"taskset -p %d `pidof pps-client` > /dev/null 2>&1", bitmask);
    sysCommand(cmdstr);
 
//  printf("\n");
 
    delete fbuf;
    return 0;
}
 
 
int getSeqNum(const char *pbuf){
 
    char *pSpc, *pNum;
    int seqNum = 0;
 
    pSpc = strpbrk((char *)pbuf, space);
 
    pNum = strpbrk(pSpc, num);
    pSpc = strpbrk(pNum, space);
    pNum = strpbrk(pSpc, num);
 
    sscanf(pNum, "%d ", &seqNum);
    return seqNum;
}
 
void showStatusEachSecond(void){
    struct timeval tv1;
    struct timespec ts2;
    char paramsBuf[MSGBUF_SZ];
    struct stat stat_buf;
    int seqNum = 0, lastSeqNum = -1;
 
    if (g.doSerialsettime == true){
        printf("\nSerial port, %s, is providing time of day from GPS Satellites\n\n", g.serialPort);
    }
    else if (g.doNISTsettime == true){
        printf("\nNIST UDP time servers are providing time of day over the Internet\n\n");
    }
 
    int dispTime = 500000;                                  // Display at half second
 
    gettimeofday(&tv1, NULL);
    ts2 = setSyncDelay(dispTime, tv1.tv_usec);
 
    for (;;){
 
        if (g.exit_loop){
            break;
        }
        nanosleep(&ts2, NULL);
 
        int fd = open(f.displayParams_file, O_RDONLY);
        if (fd == -1){
            printf("showStatusEachSecond(): Could not open f.displayParams_file");
            printf("%s", f.displayParams_file);
            printf("\n");
        }
        else {
            fstat(fd, &stat_buf);
            int sz = stat_buf.st_size;
 
            if (sz >= MSGBUF_SZ){
                printf("showStatusEachSecond() buffer too small. sz: %d\n", sz);
                close(fd);
                break;
            }
 
            int rv = read(fd, paramsBuf, sz);
            close(fd);
            if (rv == -1){
                printf("showStatusEachSecond() Read paramsBuf failed with error: %s\n", strerror(errno));
                break;
 
            }
 
            if (sz > 0){
 
                paramsBuf[sz]= '\0';
 
                char *sv = strstr(paramsBuf, "jitter");
                if (sv != NULL){                                // Is a standard status line containing "jitter".
                    seqNum = getSeqNum(paramsBuf);
 
                    if (seqNum != lastSeqNum){
                        printf("%s", paramsBuf);
                    }
                }
                else {                                          // Is informational or error message
                    seqNum += 1;
 
                    if (seqNum != lastSeqNum){
                        printf("%s", paramsBuf);
                    }
                }
                lastSeqNum = seqNum;
            }
        }
 
        gettimeofday(&tv1, NULL);
 
        ts2 = setSyncDelay(dispTime, tv1.tv_usec);
    }
    printf(" Exiting PPS-Client status display\n");
}
 
void INThandler(int sig){
    g.exit_loop = true;
}
 
bool missingArg(int argc, char *argv[], int i){
    if (i == argc - 1 || argv[i+1][0] == '-'){
        printf("Error: Missing argument for %s.\n", argv[i]);
        return true;
    }
    return false;
}
 
int daemonSaveArray(const char *requestStr, const char *filename){
    char buf[200];
 
    int fd = open_logerr(f.arrayData_file, O_CREAT | O_WRONLY | O_TRUNC, "daemonSaveArray()");
    if (fd == -1){
        printf("daemonSaveArray() Open f.arrayData_file failed\n");
        return -1;
    }
 
    strcpy(buf, requestStr);
 
    if (filename != NULL){
        strcat(buf, " ");
        strcat(buf, filename);
    }
 
    int rv = write(fd, buf, strlen(buf) + 1);
    close(fd);
    if (rv == -1){
        sprintf(g.logbuf, "daemonSaveArray() Write to tmpfs memory file failed\n");
        writeToLog(g.logbuf, "daemonSaveArray()");
        return -1;
    }
    return 0;
}
 
void printAcceptedArgs(void){
    printf("Accepts any of these:\n");
    int arrayLen = sizeof(arrayData) / sizeof(struct saveFileData);
    for (int i = 0; i < arrayLen; i++){
        printf("%s\n", arrayData[i].label);
    }
}
 
int parseSaveDataRequest(int argc, char *argv[], const char *requestStr){
 
    int arrayLen = sizeof(arrayData) / sizeof(struct saveFileData);
 
    int i;
    for (i = 0; i < arrayLen; i++){
        if (strcmp(requestStr, arrayData[i].label) == 0){
            break;
        }
    }
    if (i == arrayLen){
        printf("Arg \"%s\" not recognized\n", argv[i+1]);
        printAcceptedArgs();
        return -1;
    }
 
    char *filename = NULL;
    for (int j = 1; j < argc; j++){
        if (strcmp(argv[j], "-f") == 0){
            if (missingArg(argc, argv, j)){
                printf("Requires a filename.\n");
                return -1;
            }
            strncpy(g.strbuf, argv[j+1], STRBUF_SZ-1);
            g.strbuf[strlen(argv[j+1])] = '\0';
            filename = g.strbuf;
            break;
        }
    }
 
    if (filename != NULL){
        printf("Writing to file: %s\n", filename);
    }
    else {
        for (i = 0; i < arrayLen; i++){
            if (strcmp(requestStr, arrayData[i].label) == 0){
                printf("Writing to default file: %s\n", arrayData[i].filename);
            }
        }
    }
 
    if (daemonSaveArray(requestStr, filename) == -1){
        return -1;
    }
    return 0;
}
 
int accessDaemon(int argc, char *argv[]){
    bool verbose = false;
 
    getSharedConfigs();
 
    if (! ppsIsRunning()){                      // If not running,
        remove(f.pidFilename);                  // remove a zombie PID filename if one is found.
        return 1;
    }
 
    signal(SIGINT, INThandler);                 // Set handler to enable exiting with ctrl-c.
 
    printf("\nPPS-Client v%s is running.\n", version);
 
    if (argc > 1){
 
        for (int i = 1; i < argc; i++){
            if (strcmp(argv[i], "-v") == 0){
                verbose = true;
            }
        }
        for (int i = 1; i < argc; i++){
            if (strcmp(argv[i], "-s") == 0){    // This is a save data request.
                if (missingArg(argc, argv, i)){
                    printAcceptedArgs();
                    return -1;
                }
 
                if (parseSaveDataRequest(argc, argv, argv[i+1]) == -1){
                    return -1;
                }
                break;
            }
        }
    }
 
    if (verbose){
        printf("Displaying second-by-second state params (ctrl-c to quit):\n");
        showStatusEachSecond();
    }
 
    return 0;
}
 
void buildErrorDistrib(int timeCorrection){
    int len = ERROR_DISTRIB_LEN - 1;
    int idx = timeCorrection + len / 6;
 
    if (idx < 0){
        idx = 0;
    }
    else if (idx > len){
        idx = len;
    }
    g.errorDistrib[idx] += 1;
 
    g.errorCount += 1;
}
 
void buildJitterDistrib(int rawError){
    int len = JITTER_DISTRIB_LEN - 1;
    int idx = rawError + len / 3;
 
    if (idx < 0){
        idx = 0;
    }
    else if (idx > len){
        idx = len;
    }
    g.jitterDistrib[idx] += 1;
 
    g.jitterCount += 1;
}
 
void TERMhandler(int sig){
    signal(SIGTERM, SIG_IGN);
    sprintf(g.logbuf,"Recieved SIGTERM\n");
    writeToLog(g.logbuf, "TERMhandler()");
    g.exit_requested = true;
    signal(SIGTERM, TERMhandler);
}
 
void HUPhandler(int sig){
    signal(SIGHUP, SIG_IGN);
}
 
void recordFrequencyVars(void){
    timeval t;
    g.freqOffsetSum += g.freqOffset;
 
    g.freqOffsetDiff[g.intervalCount] = g.freqOffset - g.lastFreqOffset;
 
    g.lastFreqOffset = g.freqOffset;
    g.intervalCount += 1;
 
    if (g.intervalCount >= FIVE_MINUTES){
        gettimeofday(&t, NULL);
 
        double norm = 1.0 / (double)FREQDIFF_INTRVL;
 
        double diffSum = 0.0;
        for (int i = 0; i < FREQDIFF_INTRVL; i++){
            diffSum += g.freqOffsetDiff[i] * g.freqOffsetDiff[i];
        }
        g.freqAllanDev[g.recIndex] = sqrt(diffSum * norm * 0.5);
 
        g.timestampRec[g.recIndex] = t.tv_sec;
 
        g.freqOffsetRec[g.recIndex] = g.freqOffsetSum * norm;
 
        g.recIndex += 1;
        if (g.recIndex == NUM_5_MIN_INTERVALS){
            g.recIndex = 0;
        }
 
        g.intervalCount = 0;
        g.freqOffsetSum = 0.0;
    }
}
 
void recordOffsets(int timeCorrection){
 
    g.seq_numRec[g.recIndex2] = g.seq_num;
    g.offsetRec[g.recIndex2] = timeCorrection;
    g.freqOffsetRec2[g.recIndex2] = g.freqOffset;
 
    g.recIndex2 += 1;
    if (g.recIndex2 >= SECS_PER_10_MIN){
        g.recIndex2 = 0;
    }
}
 
int find_source(const char *path, pps_handle_t *handle, int *avail_mode)
{
    pps_params_t params;
    int ret;
 
    /* Try to find the source by using the supplied "path" name */
    ret = open(path, O_RDWR);
 
    if (ret < 0) {
        sprintf(g.logbuf, "Unable to open device \"%s\" (%m)\n", path);
        fprintf(stderr, "%s", g.logbuf);
        writeToLog(g.logbuf, "find_source()");
        sprintf(g.logbuf, "Is the PPS driver enabled?\n");
        fprintf(stderr, "%s", g.logbuf);
        writeToLog(g.logbuf, "find_source()");
        return ret;
    }
 
    /* Open the PPS source (and check the file descriptor) */
    ret = time_pps_create(ret, handle);
    if (ret < 0) {
        sprintf(g.logbuf, "cannot create a PPS source from device "
                "\"%s\" (%m)\n", path);
        writeToLog(g.logbuf, "find_source()");
        return -1;
    }
 
    /* Find out what features are supported */
    ret = time_pps_getcap(*handle, avail_mode);
    if (ret < 0) {
        sprintf(g.logbuf, "cannot get capabilities (%m)\n");
        writeToLog(g.logbuf, "find_source()");
        return -1;
    }
    if ((*avail_mode & PPS_CAPTUREASSERT) == 0) {
        sprintf(g.logbuf, "cannot CAPTUREASSERT\n");
        writeToLog(g.logbuf, "find_source()");
        return -1;
    }
 
    /* Capture assert timestamps */
    ret = time_pps_getparams(*handle, &params);
    if (ret < 0) {
        sprintf(g.logbuf, "cannot get parameters (%m)\n");
        writeToLog(g.logbuf, "find_source()");
        return -1;
    }
    params.mode |= PPS_CAPTUREASSERT;
    /* Override any previous offset if possible */
    if ((*avail_mode & PPS_OFFSETASSERT) != 0) {
        params.mode |= PPS_OFFSETASSERT;
        params.assert_offset = offset_assert;
    }
    ret = time_pps_setparams(*handle, &params);
    if (ret < 0) {
        sprintf(g.logbuf, "cannot set parameters (%m)\n");
        writeToLog(g.logbuf, "find_source()");
        return -1;
    }
 
    return 0;
}
 
int readPPSTimestamp(pps_handle_t *handle, int *avail_mode, int *tm)
{
    struct timespec timeout;
    pps_info_t infobuf;
    int ret;
 
    /* create a zero-valued timeout */
    timeout.tv_sec = 3;
    timeout.tv_nsec = 0;
 
retry:
    if (*avail_mode & PPS_CANWAIT){ /* waits for the next event */
        ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, &timeout);
    }
    else {
        sleep(1);
        ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, &timeout);
    }
    if (ret < 0) {
        if (ret == -EINTR) {
            sprintf(g.logbuf, "readPPSTimestamp(): time_pps_fetch() got a signal!\n");
            writeToLog(g.logbuf, "readPPSTimestamp");
            goto retry;
        }
 
        return -1;
    }
 
    if (g.ppsPhase == 0){
        tm[0] = (int)infobuf.assert_timestamp.tv_sec;
        tm[1] = (int)(infobuf.assert_timestamp.tv_nsec / 1000);
    }
    else {
        tm[0] = (int)infobuf.clear_timestamp.tv_sec;
        tm[1] = (int)(infobuf.clear_timestamp.tv_nsec / 1000);
    }
 
    return 0;
}
 
int getRootHome(void){
    char buf[100];
    char cmdStr[100];
 
    memset(cmdStr, 0, 100);
    strcpy(cmdStr, "echo $HOME > ");
    strcat(cmdStr, f.home_file);
 
    sysCommand(cmdStr);
 
    int fd = open(f.home_file, O_RDONLY);
    if (fd == -1){
        sprintf(g.logbuf, "getRootHome(): Unable to open file %s\n", "./Home");
        writeToLog(g.logbuf, "getRootHome()");
        return -1;
    }
 
    memset(buf, 0, 100);
 
    int rv = read(fd, buf, 99);
    if (rv == -1){
        close(fd);
        return -1;
    }
    close(fd);
 
    char *pbuf = buf;
    while (*pbuf != '/'){
        pbuf += 1;
    }
 
    char *pbufEnd = pbuf;
    while(*pbufEnd != '\n'){
        pbufEnd += 1;
    }
    *pbufEnd = '\0';
 
    strcpy(f.integral_state_file, pbuf);
    strcat(f.integral_state_file, integral_state_file);
 
    remove(f.home_file);
 
    return 0;
}