← Back to branch summary

~ubuntu-branches/debian/squeeze/ntp/squeeze-201010051545

« back to all changes in this revision

Viewing changes to ntpd/refclock_parse.c

  • Committer: Bazaar Package Importer
  • Author(s): Matt Zimmerman
  • Date: 2004-10-11 16:10:27 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20041011161027-icyjbji8ujym633o
Tags: 1:4.2.0a-10ubuntu2
Use ntp.ubuntulinux.org instead of pool.ntp.org

Show diffs side-by-side

added added

removed removed

Lines of Context:
ntpd/refclock_parse.c
802
802
        const char *cl_description;             /* device name */
803
803
        const char *cl_format;          /* fixed format */
804
804
        u_char  cl_type;                /* clock type (ntp control) */
805
 
        u_long  cl_maxunsync;           /* time to trust oscillator after loosing synch */
 
805
        u_long  cl_maxunsync;           /* time to trust oscillator after losing synch */
806
806
        u_long  cl_speed;               /* terminal input & output baudrate */
807
807
        u_long  cl_cflag;             /* terminal control flags */
808
808
        u_long  cl_iflag;             /* terminal input flags */
1181
1181
                "WHARTON 400A Series clock Output Format 1",    /* fixed format */
1182
1182
                        /* Must match a format-name in a libparse/clk_xxx.c file */
1183
1183
                DCF_TYPE,                       /* clock type (ntp control) */
1184
 
                (1*60*60),                      /* time to trust oscillator after loosing synch */
 
1184
                (1*60*60),                      /* time to trust oscillator after losing synch */
1185
1185
                B9600,                          /* terminal input & output baudrate */
1186
1186
                (CS8|CREAD|PARENB|CLOCAL|HUPCL),/* terminal control flags */
1187
1187
                0,                              /* terminal input flags */
1240
1240
 
1241
1241
static int ncltypes = sizeof(parse_clockinfo) / sizeof(struct parse_clockinfo);
1242
1242
 
1243
 
#define CLK_REALTYPE(x) ((int)(((x)->ttlmax) & 0x7F))
 
1243
#define CLK_REALTYPE(x) ((int)(((x)->ttl) & 0x7F))
1244
1244
#define CLK_TYPE(x)     ((CLK_REALTYPE(x) >= ncltypes) ? ~0 : CLK_REALTYPE(x))
1245
1245
#define CLK_UNIT(x)     ((int)REFCLOCKUNIT(&(x)->srcadr))
1246
 
#define CLK_PPS(x)      (((x)->ttlmax) & 0x80)
 
1246
#define CLK_PPS(x)      (((x)->ttl) & 0x80)
1247
1247
 
1248
1248
/*
1249
1249
 * Other constant stuff
3095
3095
                        NLOG(NLOG_CLOCKEVENT) /* conditional if clause for conditional syslog */
3096
3096
                                ERR(ERR_BADEVENT)
3097
3097
                                msyslog(LOG_ERR,
3098
 
                                        "clock %s fault '%s' (0x%02x)", refnumtoa(parse->peer->srcadr.sin_addr.s_addr), ceventstr(event),
 
3098
                                        "clock %s fault '%s' (0x%02x)", refnumtoa(&parse->peer->srcadr), ceventstr(event),
3099
3099
                                        (u_int)event);
3100
3100
                }
3101
3101
                else
3103
3103
                        NLOG(NLOG_CLOCKEVENT) /* conditional if clause for conditional syslog */
3104
3104
                                if (event == CEVNT_NOMINAL || list_err(parse, ERR_BADEVENT))
3105
3105
                                    msyslog(LOG_INFO,
3106
 
                                            "clock %s event '%s' (0x%02x)", refnumtoa(parse->peer->srcadr.sin_addr.s_addr), ceventstr(event),
 
3106
                                            "clock %s event '%s' (0x%02x)", refnumtoa(&parse->peer->srcadr), ceventstr(event),
3107
3107
                                            (u_int)event);
3108
3108
                }
3109
3109
 
3728
3728
                        case GPS_ANT_INFO:
3729
3729
                                {
3730
3730
                                        ANT_INFO antinfo;
3731
 
                                        char buffer[512];
3732
 
                                        char *p;
 
3731
                                        u_char buffer[512];
 
3732
                                        u_char *p;
3733
3733
                                        
3734
3734
                                        get_mbg_antinfo(&bufp, &antinfo);
3735
 
                                        sprintf((char *)buffer, "meinberg_antenna_status=\"");
 
3735
                                        sprintf(buffer, "meinberg_antenna_status=\"");
3736
3736
                                        p = buffer + strlen(buffer);
3737
3737
                                        
3738
3738
                                        switch (antinfo.status)
3750
3750
                                                                CLK_UNIT(parse->peer), p);
3751
3751
                                                
3752
3752
                                                p += strlen(p);
3753
 
                                                mbg_tm_str((unsigned char **)&p, &antinfo.tm_disconn);
 
3753
                                                mbg_tm_str(&p, &antinfo.tm_disconn);
3754
3754
                                                *p = '\0';
3755
3755
                                                break;
3756
3756
                    
3757
3757
                                        case ANT_RECONN:
3758
3758
                                                strcat(p, "RECONNECTED on ");
3759
3759
                                                p += strlen(p);
3760
 
                                                mbg_tm_str((unsigned char **)&p, &antinfo.tm_reconn);
 
3760
                                                mbg_tm_str(&p, &antinfo.tm_reconn);
3761
3761
                                                sprintf(p, ", reconnect clockoffset %c%ld.%07ld s, disconnect time ",
3762
3762
                                                        (antinfo.delta_t < 0) ? '-' : '+',
3763
3763
                                                        ABS(antinfo.delta_t) / 10000,
3764
3764
                                                        ABS(antinfo.delta_t) % 10000);
3765
3765
                                                p += strlen(p);
3766
 
                                                mbg_tm_str((unsigned char **)&p, &antinfo.tm_disconn);
 
3766
                                                mbg_tm_str(&p, &antinfo.tm_disconn);
3767
3767
                                                *p = '\0';
3768
3768
                                                break;
3769
3769
                    
3786
3786
                        case GPS_CFGH:
3787
3787
                                {
3788
3788
                                        CFGH cfgh;
3789
 
                                        char buffer[512];
3790
 
                                        char *p;
 
3789
                                        u_char buffer[512];
 
3790
                                        u_char *p;
3791
3791
                                        
3792
3792
                                        get_mbg_cfgh(&bufp, &cfgh);
3793
3793
                                        if (cfgh.valid)
3797
3797
                                                p = buffer;
3798
3798
                                                strcpy(buffer, "gps_tot_51=\"");
3799
3799
                                                p += strlen(p);
3800
 
                                                mbg_tgps_str((unsigned char **)&p, &cfgh.tot_51);
 
3800
                                                mbg_tgps_str(&p, &cfgh.tot_51);
3801
3801
                                                *p++ = '"';
3802
3802
                                                *p   = '\0';
3803
3803
                                                set_var(&parse->kv, buffer, sizeof(buffer), RO);
3805
3805
                                                p = buffer;
3806
3806
                                                strcpy(buffer, "gps_tot_63=\"");
3807
3807
                                                p += strlen(p);
3808
 
                                                mbg_tgps_str((unsigned char **)&p, &cfgh.tot_63);
 
3808
                                                mbg_tgps_str(&p, &cfgh.tot_63);
3809
3809
                                                *p++ = '"';
3810
3810
                                                *p   = '\0';
3811
3811
                                                set_var(&parse->kv, buffer, sizeof(buffer), RO);
3813
3813
                                                p = buffer;
3814
3814
                                                strcpy(buffer, "gps_t0a=\"");
3815
3815
                                                p += strlen(p);
3816
 
                                                mbg_tgps_str((unsigned char **)&p, &cfgh.t0a);
 
3816
                                                mbg_tgps_str(&p, &cfgh.t0a);
3817
3817
                                                *p++ = '"';
3818
3818
                                                *p   = '\0';
3819
3819
                                                set_var(&parse->kv, buffer, sizeof(buffer), RO);
5176
5176
}
5177
5177
#else
5178
5178
static int
5179
 
rawdcfdtr_init(
 
5179
rawdcfdtr_init_1(
5180
5180
        struct parseunit *parse
5181
5181
        )
5182
5182
{