6 files changed, 502 insertions, 36 deletions

diff --git a/.gitignore b/.gitignore
index 02ca61e..6f903d6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -94,7 +94,7 @@ NP-VERSION-FILE
 /gl/limits.h
 /gl/malloc/dynarray-skeleton.gl.h
 /gl/malloc/dynarray.gl.h
-/gl/stdckdint.
+/gl/stdckdint.h
 
 # /lib/
 /lib/.deps
diff --git a/plugins-root/check_icmp.c b/plugins-root/check_icmp.c
index 1d47e9f..0401788 100644
--- a/plugins-root/check_icmp.c
+++ b/plugins-root/check_icmp.c
@@ -109,18 +109,35 @@ typedef struct rta_host {
         unsigned char icmp_type, icmp_code; /* type and code from errors */
         unsigned short flags;        /* control/status flags */
         double rta;                  /* measured RTA */
+        int                     rta_status;
         double rtmax;                /* max rtt */
         double rtmin;                /* min rtt */
+        double jitter;                  /* measured jitter */
+        int                     jitter_status;
+        double jitter_max;                /* jitter rtt */
+        double jitter_min;                /* jitter rtt */
+        double EffectiveLatency;
+        double mos;                                                                     /* Mean opnion score */
+        int                     mos_status;
+        double  score;                                                  /* score */
+        int                     score_status;
+        u_int last_tdiff;
+        u_int   last_icmp_seq;        /* Last ICMP_SEQ to check out of order pkts */
         unsigned char pl;            /* measured packet loss */
+        int                     pl_status;
         struct rta_host *next;       /* linked list */
+        int     order_status;
 } rta_host;
 
 #define FLAG_LOST_CAUSE 0x01  /* decidedly dead target. */
 
 /* threshold structure. all values are maximum allowed, exclusive */
 typedef struct threshold {
-        unsigned char pl;    /* max allowed packet loss in percent */
-        unsigned int rta;  /* roundtrip time average, microseconds */
+        unsigned char pl;                       /* max allowed packet loss in percent */
+        unsigned int rta;                       /* roundtrip time average, microseconds */
+        double jitter;  /* jitter time average, microseconds */
+        double mos;                     /* MOS */
+        double score;           /* Score */
 } threshold;
 
 /* the data structure */
@@ -188,6 +205,7 @@ static int wait_for_reply(int, u_int);
 static int recvfrom_wto(int, void *, unsigned int, struct sockaddr *, u_int *, struct timeval*);
 static int send_icmp_ping(int, struct rta_host *);
 static int get_threshold(char *str, threshold *th);
+static int get_threshold2(char *str, threshold *, threshold *, int type);
 static void run_checks(void);
 static void set_source_ip(char *);
 static int add_target(char *);
@@ -224,6 +242,12 @@ static unsigned int warn_down = 1, crit_down = 1; /* host down threshold values
 static int min_hosts_alive = -1;
 float pkt_backoff_factor = 1.5;
 float target_backoff_factor = 1.5;
+int     rta_mode=0;
+int     pl_mode=0;
+int     jitter_mode=0;
+int     score_mode=0;
+int     mos_mode=0;
+int     order_mode=0;
 
 /** code start **/
 static void
@@ -393,12 +417,14 @@ main(int argc, char **argv)
         int icmp_sockerrno, udp_sockerrno, tcp_sockerrno;
         int result;
         struct rta_host *host;
+#ifdef HAVE_SIGACTION
+        struct sigaction sig_action;
+#endif
 #ifdef SO_TIMESTAMP
         int on = 1;
 #endif
         char *source_ip = NULL;
-        char * opts_str = "vhVw:c:n:p:t:H:s:i:b:I:l:m:64";
-
+        char * opts_str = "vhVw:c:n:p:t:H:s:i:b:I:l:m:P:R:J:S:M:O64";
         setlocale (LC_ALL, "");
         bindtextdomain (PACKAGE, LOCALEDIR);
         textdomain (PACKAGE);
@@ -422,10 +448,19 @@ main(int argc, char **argv)
         table = NULL;
 
         mode = MODE_RTA;
+        /* Default critical thresholds */
         crit.rta = 500000;
         crit.pl = 80;
+        crit.jitter = 50;
+        crit.mos= 3;
+        crit.score=70;
+        /* Default warning thresholds */
         warn.rta = 200000;
         warn.pl = 40;
+        warn.jitter = 40;
+        warn.mos= 3.5;
+        warn.score=80;
+
         protocols = HAVE_ICMP | HAVE_UDP | HAVE_TCP;
         pkt_interval = 80000;  /* 80 msec packet interval by default */
         packets = 5;
@@ -481,7 +516,7 @@ main(int argc, char **argv)
         /* Reset argument scanning */
         optind = 1;
 
-        unsigned short size;
+        unsigned long size;
         /* parse the arguments */
         for(i = 1; i < argc; i++) {
                 while((arg = getopt(argc, argv, opts_str)) != EOF) {
@@ -490,7 +525,7 @@ main(int argc, char **argv)
                                 debug++;
                                 break;
                         case 'b':
-                                size = (unsigned short)strtol(optarg,NULL,0);
+                                size = strtol(optarg,NULL,0);
                                 if (size >= (sizeof(struct icmp) + sizeof(struct icmp_ping_data)) &&
                                     size < MAX_PING_DATA) {
                                         icmp_data_size = size;
@@ -545,6 +580,29 @@ main(int argc, char **argv)
                                 print_help ();
                                 exit (STATE_UNKNOWN);
                                 break;
+                        case 'R': /* RTA mode */
+                                get_threshold2(optarg, &warn, &crit,1);
+                                rta_mode=1;
+                                break;
+                        case 'P': /* packet loss mode */
+                                get_threshold2(optarg, &warn, &crit,2);
+                                pl_mode=1;
+                                break;
+                        case 'J': /* jitter mode */
+                                get_threshold2(optarg, &warn, &crit,3);
+                                jitter_mode=1;
+                                break;
+                        case 'M': /* MOS mode */
+                                get_threshold2(optarg, &warn, &crit,4);
+                                mos_mode=1;
+                                break;
+                        case 'S': /* score mode */
+                                get_threshold2(optarg, &warn, &crit,5);
+                                score_mode=1;
+                                break;
+                        case 'O': /* out of order mode */
+                                order_mode=1;
+                                break;
                         }
                 }
         }
@@ -631,11 +689,25 @@ main(int argc, char **argv)
         if(warn.pl > crit.pl) warn.pl = crit.pl;
         if(warn.rta > crit.rta) warn.rta = crit.rta;
         if(warn_down > crit_down) crit_down = warn_down;
-
+        if(warn.jitter > crit.jitter) crit.jitter = warn.jitter;
+        if(warn.mos < crit.mos) warn.mos = crit.mos;
+        if(warn.score < crit.score) warn.score = crit.score;
+
+#ifdef HAVE_SIGACTION
+        sig_action.sa_sigaction = NULL;
+        sig_action.sa_handler = finish;
+        sigfillset(&sig_action.sa_mask);
+        sig_action.sa_flags = SA_NODEFER|SA_RESTART;
+        sigaction(SIGINT, &sig_action, NULL);
+        sigaction(SIGHUP, &sig_action, NULL);
+        sigaction(SIGTERM, &sig_action, NULL);
+        sigaction(SIGALRM, &sig_action, NULL);
+#else /* HAVE_SIGACTION */
         signal(SIGINT, finish);
         signal(SIGHUP, finish);
         signal(SIGTERM, finish);
         signal(SIGALRM, finish);
+#endif /* HAVE_SIGACTION */
         if(debug) printf("Setting alarm timeout to %u seconds\n", timeout);
         alarm(timeout);
 
@@ -685,7 +757,7 @@ main(int argc, char **argv)
         }
 
         host = list;
-        table = (struct rta_host**)malloc(sizeof(struct rta_host **) * targets);
+        table = malloc(sizeof(struct rta_host *) * targets);
         i = 0;
         while(host) {
                 host->id = i*packets;
@@ -772,6 +844,7 @@ wait_for_reply(int sock, u_int t)
         struct icmp_ping_data data;
         struct timeval wait_start, now;
         u_int tdiff, i, per_pkt_wait;
+        double jitter_tmp;
 
         if (!(packet.buf = malloc(icmp_pkt_size))) {
                 crash("send_icmp_ping(): failed to malloc %d bytes for send buffer",
@@ -890,12 +963,43 @@ wait_for_reply(int sock, u_int t)
 
                 tdiff = get_timevaldiff(&data.stime, &now);
 
+                if (host->last_tdiff>0) {
+                        /* Calculate jitter */
+                        if (host->last_tdiff > tdiff) {
+                                jitter_tmp = host->last_tdiff - tdiff;
+                        }
+                        else {
+                                jitter_tmp = tdiff - host->last_tdiff;
+                        }
+                        if (host->jitter==0) {
+                                host->jitter=jitter_tmp;
+                                host->jitter_max=jitter_tmp;
+                                host->jitter_min=jitter_tmp;
+                        }
+                        else {
+                                host->jitter+=jitter_tmp;
+                                if (jitter_tmp < host->jitter_min)
+                                        host->jitter_min=jitter_tmp;
+                                if (jitter_tmp > host->jitter_max)
+                                        host->jitter_max=jitter_tmp;
+                        }
+
+                        /* Check if packets in order */
+                        if (host->last_icmp_seq >= packet.icp->icmp_seq)
+                                host->order_status=STATE_CRITICAL;
+                }
+                host->last_tdiff=tdiff;
+
+                host->last_icmp_seq=packet.icp->icmp_seq;
+
+                //printf("%d tdiff %d host->jitter %u  host->last_tdiff %u\n", icp.icmp_seq, tdiff, host->jitter, host->last_tdiff);
+
                 host->time_waited += tdiff;
                 host->icmp_recv++;
                 icmp_recv++;
-                if (tdiff > host->rtmax)
+                if (tdiff > (int)host->rtmax)
                         host->rtmax = tdiff;
-                if (tdiff < host->rtmin)
+                if (tdiff < (int)host->rtmin)
                         host->rtmin = tdiff;
 
                 if(debug) {
@@ -1094,8 +1198,10 @@ recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr,
         hdr.msg_namelen = slen;
         hdr.msg_iov = &iov;
         hdr.msg_iovlen = 1;
+#ifdef HAVE_MSGHDR_MSG_CONTROL
         hdr.msg_control = ans_data;
         hdr.msg_controllen = sizeof(ans_data);
+#endif
 
         ret = recvmsg(sock, &hdr, 0);
 #ifdef SO_TIMESTAMP
@@ -1125,6 +1231,8 @@ finish(int sig)
         {"OK", "WARNING", "CRITICAL", "UNKNOWN", "DEPENDENT"};
         int hosts_ok = 0;
         int hosts_warn = 0;
+        int this_status;
+        double R;
 
         alarm(0);
         if(debug > 1) printf("finish(%d) called\n", sig);
@@ -1140,9 +1248,11 @@ finish(int sig)
         }
 
         /* iterate thrice to calculate values, give output, and print perfparse */
+        status=STATE_OK;
         host = list;
 
         while(host) {
+                this_status = STATE_OK;
                 if(!host->icmp_recv) {
                         /* rta 0 is ofcourse not entirely correct, but will still show up
                          * conspicuously as missing entries in perfparse and cacti */
@@ -1156,21 +1266,107 @@ finish(int sig)
                         pl = ((host->icmp_sent - host->icmp_recv) * 100) / host->icmp_sent;
                         rta = (double)host->time_waited / host->icmp_recv;
                 }
+                if (host->icmp_recv>1) {
+                        host->jitter=(host->jitter / (host->icmp_recv - 1)/1000);
+                        host->EffectiveLatency = (rta/1000) + host->jitter * 2 + 10;
+                        if (host->EffectiveLatency < 160)
+                           R = 93.2 - (host->EffectiveLatency / 40);
+                        else
+                           R = 93.2 - ((host->EffectiveLatency - 120) / 10);
+                        R = R - (pl * 2.5);
+                        if (R<0) R=0;
+                        host->score = R;
+                        host->mos= 1 + ((0.035) * R) + ((.000007) * R * (R-60) * (100-R));
+                }
+                else {
+                        host->jitter=0;
+                        host->jitter_min=0;
+                        host->jitter_max=0;
+                        host->mos=0;
+                }
                 host->pl = pl;
                 host->rta = rta;
-                if(pl >= crit.pl || rta >= crit.rta) {
-                        status = STATE_CRITICAL;
+
+                /* if no new mode selected, use old schema */
+                if (!rta_mode && !pl_mode && !jitter_mode && !score_mode && !mos_mode && !order_mode) {
+                        rta_mode=1;
+                        pl_mode=1;
+                }
+
+#define THIS_STATUS_WARNING this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status)
+                /* Check which mode is on and do the warn / Crit stuff */
+                if (rta_mode) {
+                        if(rta >= crit.rta) {
+                                this_status = STATE_CRITICAL;
+                                status = STATE_CRITICAL;
+                                host->rta_status=STATE_CRITICAL;
+                        }
+                        else if(status!=STATE_CRITICAL && (rta >= warn.rta)) {
+                                THIS_STATUS_WARNING;
+                                status = STATE_WARNING;
+                                host->rta_status=STATE_WARNING;
+                        }
+                }
+                if (pl_mode) {
+                        if(pl >= crit.pl) {
+                                this_status = STATE_CRITICAL;
+                                status = STATE_CRITICAL;
+                                host->pl_status=STATE_CRITICAL;
+                        }
+                        else if(status!=STATE_CRITICAL && (pl >= warn.pl)) {
+                                THIS_STATUS_WARNING;
+                                status = STATE_WARNING;
+                                host->pl_status=STATE_WARNING;
+                        }
+                }
+                if (jitter_mode) {
+                        if(host->jitter >= crit.jitter) {
+                                this_status = STATE_CRITICAL;
+                                status = STATE_CRITICAL;
+                                host->jitter_status=STATE_CRITICAL;
+                        }
+                        else if(status!=STATE_CRITICAL && (host->jitter >= warn.jitter)) {
+                                THIS_STATUS_WARNING;
+                                status = STATE_WARNING;
+                                host->jitter_status=STATE_WARNING;
+                        }
+                }
+                if (mos_mode) {
+                        if(host->mos <= crit.mos) {
+                                this_status = STATE_CRITICAL;
+                                status = STATE_CRITICAL;
+                                host->mos_status=STATE_CRITICAL;
+                        }
+                        else if(status!=STATE_CRITICAL && (host->mos <= warn.mos)) {
+                                THIS_STATUS_WARNING;
+                                status = STATE_WARNING;
+                                host->mos_status=STATE_WARNING;
+                        }
                 }
-                else if(!status && (pl >= warn.pl || rta >= warn.rta)) {
-                        status = STATE_WARNING;
+                if (score_mode) {
+                        if(host->score <= crit.score) {
+                                this_status = STATE_CRITICAL;
+                                status = STATE_CRITICAL;
+                                host->score_status=STATE_CRITICAL;
+                        }
+                        else if(status!=STATE_CRITICAL && (host->score <= warn.score)) {
+                                THIS_STATUS_WARNING;
+                                status = STATE_WARNING;
+                                host->score_status=STATE_WARNING;
+                        }
+                }
+
+                if (this_status == STATE_WARNING) {
                         hosts_warn++;
                 }
-                else {
+                else if (this_status == STATE_OK) {
                         hosts_ok++;
                 }
 
                 host = host->next;
         }
+
+
         /* this is inevitable */
         if(!targets_alive) status = STATE_CRITICAL;
         if(min_hosts_alive > -1) {
@@ -1181,6 +1377,7 @@ finish(int sig)
 
         host = list;
         while(host) {
+
                 if(debug) puts("");
                 if(i) {
                         if(i < targets) printf(" :: ");
@@ -1189,6 +1386,8 @@ finish(int sig)
                 i++;
                 if(!host->icmp_recv) {
                         status = STATE_CRITICAL;
+                        host->rtmin=0;
+                        host->jitter_min=0;
                         if(host->flags & FLAG_LOST_CAUSE) {
                                 char address[INET6_ADDRSTRLEN];
                                 parse_address(&host->error_addr, address, sizeof(address));
@@ -1203,26 +1402,108 @@ finish(int sig)
                         }
                 }
                 else {  /* !icmp_recv */
-                        printf("%s: rta %0.3fms, lost %u%%",
-                                   host->name, host->rta / 1000, host->pl);
+                        printf("%s", host->name);
+                        /* rta text output */
+                        if (rta_mode) {
+                                if (status == STATE_OK)
+                                        printf(" rta %0.3fms", host->rta / 1000);
+                                else if (status==STATE_WARNING && host->rta_status==status)
+                                        printf(" rta %0.3fms > %0.3fms", (float)host->rta / 1000, (float)warn.rta/1000);
+                                else if (status==STATE_CRITICAL && host->rta_status==status)
+                                        printf(" rta %0.3fms > %0.3fms", (float)host->rta / 1000, (float)crit.rta/1000);
+                        }
+                        /* pl text output */
+                        if (pl_mode) {
+                                if (status == STATE_OK)
+                                        printf(" lost %u%%", host->pl);
+                                else if (status==STATE_WARNING && host->pl_status==status)
+                                        printf(" lost %u%% > %u%%", host->pl, warn.pl);
+                                else if (status==STATE_CRITICAL && host->pl_status==status)
+                                        printf(" lost %u%% > %u%%", host->pl, crit.pl);
+                        }
+                        /* jitter text output */
+                        if (jitter_mode) {
+                                if (status == STATE_OK)
+                                        printf(" jitter %0.3fms", (float)host->jitter);
+                                else if (status==STATE_WARNING && host->jitter_status==status)
+                                        printf(" jitter %0.3fms > %0.3fms", (float)host->jitter, warn.jitter);
+                                else if (status==STATE_CRITICAL && host->jitter_status==status)
+                                        printf(" jitter %0.3fms > %0.3fms", (float)host->jitter, crit.jitter);
+                        }
+                        /* mos text output */
+                        if (mos_mode) {
+                                if (status == STATE_OK)
+                                        printf(" MOS %0.1f", (float)host->mos);
+                                else if (status==STATE_WARNING && host->mos_status==status)
+                                        printf(" MOS %0.1f < %0.1f", (float)host->mos, (float)warn.mos);
+                                else if (status==STATE_CRITICAL && host->mos_status==status)
+                                        printf(" MOS %0.1f < %0.1f", (float)host->mos, (float)crit.mos);
+                        }
+                        /* score text output */
+                        if (score_mode) {
+                                if (status == STATE_OK)
+                                        printf(" Score %u", (int)host->score);
+                                else if (status==STATE_WARNING && host->score_status==status )
+                                        printf(" Score %u < %u", (int)host->score, (int)warn.score);
+                                else if (status==STATE_CRITICAL && host->score_status==status )
+                                        printf(" Score %u < %u", (int)host->score, (int)crit.score);
+                        }
+                        /* order statis text output */
+                        if (order_mode) {
+                                if (status == STATE_OK)
+                                        printf(" Packets in order");
+                                else if (status==STATE_CRITICAL && host->order_status==status)
+                                        printf(" Packets out of order");
+                        }
                 }
-
                 host = host->next;
         }
 
         /* iterate once more for pretty perfparse output */
-        printf("|");
+        if (!(!rta_mode && !pl_mode && !jitter_mode && !score_mode && !mos_mode && order_mode)) {
+                        printf("|");
+        }
         i = 0;
         host = list;
         while(host) {
                 if(debug) puts("");
-                printf("%srta=%0.3fms;%0.3f;%0.3f;0; %spl=%u%%;%u;%u;; %srtmax=%0.3fms;;;; %srtmin=%0.3fms;;;; ",
+                if (rta_mode && host->pl<100) {
+                        printf("%srta=%0.3fms;%0.3f;%0.3f;0; %srtmax=%0.3fms;;;; %srtmin=%0.3fms;;;; ",
                            (targets > 1) ? host->name : "",
                            host->rta / 1000, (float)warn.rta / 1000, (float)crit.rta / 1000,
-                           (targets > 1) ? host->name : "", host->pl, warn.pl, crit.pl,
                            (targets > 1) ? host->name : "", (float)host->rtmax / 1000,
                            (targets > 1) ? host->name : "", (host->rtmin < INFINITY) ? (float)host->rtmin / 1000 : (float)0);
-
+                }
+                if (pl_mode) {
+                        printf("%spl=%u%%;%u;%u;0;100 ", (targets > 1) ? host->name : "", host->pl, warn.pl, crit.pl);
+                }
+                if (jitter_mode && host->pl<100) {
+                        printf("%sjitter_avg=%0.3fms;%0.3f;%0.3f;0; %sjitter_max=%0.3fms;;;; %sjitter_min=%0.3fms;;;; ",
+                                (targets > 1) ? host->name : "",
+                                (float)host->jitter,
+                                (float)warn.jitter,
+                                (float)crit.jitter,
+                                (targets > 1) ? host->name : "",
+                                (float)host->jitter_max / 1000, (targets > 1) ? host->name : "",
+                                (float)host->jitter_min / 1000
+                        );
+                }
+                if (mos_mode && host->pl<100) {
+                        printf("%smos=%0.1f;%0.1f;%0.1f;0;5 ",
+                                (targets > 1) ? host->name : "",
+                                (float)host->mos,
+                                (float)warn.mos,
+                                (float)crit.mos
+                        );
+                }
+                if (score_mode && host->pl<100) {
+                        printf("%sscore=%u;%u;%u;0;100 ",
+                                (targets > 1) ? host->name : "",
+                                (int)host->score,
+                                (int)warn.score,
+                                (int)crit.score
+                        );
+                }
                 host = host->next;
         }
 
@@ -1312,6 +1593,7 @@ add_target_ip(char *arg, struct sockaddr_storage *in)
         /* set the values. use calling name for output */
         host->name = strdup(arg);
 
+
         /* fill out the sockaddr_storage struct */
         if(address_family == AF_INET) {
                 host_sin = (struct sockaddr_in *)&host->saddr_in;
@@ -1324,7 +1606,22 @@ add_target_ip(char *arg, struct sockaddr_storage *in)
                 memcpy(host_sin6->sin6_addr.s6_addr, sin6->sin6_addr.s6_addr, sizeof host_sin6->sin6_addr.s6_addr);
         }
 
+        /* fill out the sockaddr_in struct */
         host->rtmin = INFINITY;
+        host->rtmax = 0;
+        host->jitter=0;
+        host->jitter_max=0;
+        host->jitter_min=INFINITY;
+        host->last_tdiff=0;
+        host->order_status=STATE_OK;
+        host->last_icmp_seq=0;
+        host->rta_status=0;
+        host->pl_status=0;
+        host->jitter_status=0;
+        host->mos_status=0;
+        host->score_status=0;
+        host->pl_status=0;
+
 
         if(!list) list = cursor = host;
         else cursor->next = host;
@@ -1472,7 +1769,7 @@ get_timevar(const char *str)
 
         /* unit might be given as ms|m (millisec),
          * us|u (microsec) or just plain s, for seconds */
-        u = p = '\0';
+        p = '\0';
         u = str[len - 1];
         if(len >= 2 && !isdigit((int)str[len - 2])) p = str[len - 2];
         if(p && u == 's') u = p;
@@ -1530,6 +1827,46 @@ get_threshold(char *str, threshold *th)
         return 0;
 }
 
+/* not too good at checking errors, but it'll do (main() should barfe on -1) */
+static int
+get_threshold2(char *str, threshold *warn, threshold *crit, int type)
+{
+        char *p = NULL, i = 0;
+
+        if(!str || !strlen(str) || !warn || !crit) return -1;
+        /* pointer magic slims code by 10 lines. i is bof-stop on stupid libc's */
+        p = &str[strlen(str) - 1];
+        while(p != &str[0]) {
+                if( (*p == 'm') || (*p == '%') ) *p = '\0';
+                else if(*p == ',' && i) {
+                        *p = '\0';      /* reset it so get_timevar(str) works nicely later */
+                        if (type==1)
+                                crit->rta = atof(p+1)*1000;
+                        else if  (type==2)
+                                crit->pl = (unsigned char)strtoul(p+1, NULL, 0);
+                        else if  (type==3)
+                                crit->jitter = atof(p+1);
+                        else if (type==4)
+                                crit->mos = atof(p+1);
+                        else if (type==5)
+                                crit->score = atof(p+1);
+                }
+                i = 1;
+                p--;
+        }
+        if (type==1)
+                warn->rta = atof(p)*1000;
+        else if (type==2)
+                warn->pl = (unsigned char)strtoul(p, NULL, 0);
+        if (type==3)
+                warn->jitter = atof(p);
+        else if (type==4)
+                warn->mos = atof(p);
+        else if (type==5)
+                warn->score = atof(p);
+        return 0;
+}
+
 unsigned short
 icmp_checksum(uint16_t *p, size_t n)
 {
@@ -1555,10 +1892,9 @@ icmp_checksum(uint16_t *p, size_t n)
 void
 print_help(void)
 {
-
   /*print_revision (progname);*/ /* FIXME: Why? */
-
   printf ("Copyright (c) 2005 Andreas Ericsson <ae@op5.se>\n");
+
   printf (COPYRIGHT, copyright, email);
 
   printf ("\n\n");
@@ -1578,11 +1914,29 @@ print_help(void)
   printf (" %s\n", "-c");
   printf ("    %s", _("critical threshold (currently "));
   printf ("%0.3fms,%u%%)\n", (float)crit.rta / 1000, crit.pl);
+
+  printf (" %s\n", "-R");
+  printf ("    %s\n", _("RTA, round trip average,  mode  warning,critical, ex. 100ms,200ms unit in ms"));
+  printf (" %s\n", "-P");
+  printf ("    %s\n", _("packet loss mode, ex. 40%,50% , unit in %"));
+  printf (" %s\n", "-J");
+  printf ("    %s\n", _("jitter mode  warning,critical, ex. 40.000ms,50.000ms , unit in ms "));
+  printf (" %s\n", "-M");
+  printf ("    %s\n", _("MOS mode, between 0 and 4.4  warning,critical, ex. 3.5,3.0"));
+  printf (" %s\n", "-S");
+  printf ("    %s\n", _("score  mode, max value 100  warning,critical, ex. 80,70 "));
+  printf (" %s\n", "-O");
+  printf ("    %s\n", _("detect out of order ICMP packts "));
+  printf (" %s\n", "-H");
+  printf ("    %s\n", _("specify a target"));
   printf (" %s\n", "-s");
   printf ("    %s\n", _("specify a source IP address or device name"));
   printf (" %s\n", "-n");
   printf ("    %s", _("number of packets to send (currently "));
   printf ("%u)\n",packets);
+  printf (" %s\n", "-p");
+  printf ("    %s", _("number of packets to send (currently "));
+  printf ("%u)\n",packets);
   printf (" %s\n", "-i");
   printf ("    %s", _("max packet interval (currently "));
   printf ("%0.3fms)\n",(float)pkt_interval / 1000);
@@ -1603,9 +1957,9 @@ print_help(void)
   printf ("    %s %u + %d)\n", _("Packet size will be data bytes + icmp header (currently"),icmp_data_size, ICMP_MINLEN);
   printf (" %s\n", "-v");
   printf ("    %s\n", _("verbose"));
-
   printf ("\n");
   printf ("%s\n", _("Notes:"));
+  printf (" %s\n", _("If none of R,P,J,M,S or O is specified, default behavior is -R -P"));
   printf (" %s\n", _("The -H switch is optional. Naming a host (or several) to check is not."));
   printf ("\n");
   printf (" %s\n", _("Threshold format for -w and -c is 200.25,60% for 200.25 msec RTA and 60%"));
diff --git a/plugins-root/t/check_icmp.t b/plugins-root/t/check_icmp.t
index 96addd3..4f9db86 100644
--- a/plugins-root/t/check_icmp.t
+++ b/plugins-root/t/check_icmp.t
@@ -12,14 +12,14 @@ my $allow_sudo = getTestParameter( "NP_ALLOW_SUDO",
         "no" );
 
 if ($allow_sudo eq "yes" or $> == 0) {
-        plan tests => 20;
+        plan tests => 39;
 } else {
         plan skip_all => "Need sudo to test check_icmp";
 }
 my $sudo = $> == 0 ? '' : 'sudo';
 
-my $successOutput = '/OK - .*?: rta (?:[\d\.]+ms)|(?:nan), lost \d+%/';
-my $failureOutput = '/(WARNING|CRITICAL) - .*?: rta [\d\.]+ms, lost \d%/';
+my $successOutput = '/OK - .*? rta (?:[\d\.]+ms)|(?:nan), lost \d+%/';
+my $failureOutput = '/(WARNING|CRITICAL) - .*? rta (?:[\d\.]+ms > [\d\.]+ms|nan)/';
 
 my $host_responsive    = getTestParameter( "NP_HOST_RESPONSIVE",
                                 "The hostname of system responsive to network requests",
@@ -54,7 +54,7 @@ is( $res->return_code, 2, "Syntax ok, with forced critical" );
 like( $res->output, $failureOutput, "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100%"
+        "$sudo ./check_icmp -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100% -t 2"
         );
 is( $res->return_code, 2, "Timeout - host nonresponsive" );
 like( $res->output, '/100%/', "Error contains '100%' string (for 100% packet loss)" );
@@ -66,13 +66,13 @@ is( $res->return_code, 3, "No hostname" );
 like( $res->output, '/No hosts to check/', "Output with appropriate error message");
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100% -n 1 -m 0"
+        "$sudo ./check_icmp -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100% -n 1 -m 0 -t 2"
         );
 is( $res->return_code, 0, "One host nonresponsive - zero required" );
 like( $res->output, $successOutput, "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100% -n 1 -m 1"
+        "$sudo ./check_icmp -H $host_responsive -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100% -n 1 -m 1 -t 2"
         );
 is( $res->return_code, 0, "One of two host nonresponsive - one required" );
 like( $res->output, $successOutput, "Output OK" );
@@ -94,3 +94,49 @@ $res = NPTest->testCmd(
         );
 is( $res->return_code, 0, "Try max packet size" );
 like( $res->output, $successOutput, "Output OK - Didn't overflow" );
+
+$res = NPTest->testCmd(
+        "$sudo ./check_icmp -H $host_responsive -R 100,100 -n 1 -t 2"
+        );
+is( $res->return_code, 0, "rta works" );
+like( $res->output, $successOutput, "Output OK" );
+$res = NPTest->testCmd(
+        "$sudo ./check_icmp -H $host_responsive -P 80,90 -n 1 -t 2"
+        );
+is( $res->return_code, 0, "pl works" );
+like( $res->output, '/lost 0%/', "Output OK" );
+
+$res = NPTest->testCmd(
+        "$sudo ./check_icmp -H $host_responsive -J 80,90 -t 2"
+        );
+is( $res->return_code, 0, "jitter works" );
+like( $res->output, '/jitter \d/', "Output OK" );
+
+$res = NPTest->testCmd(
+        "$sudo ./check_icmp -H $host_responsive -M 4,3 -t 2"
+        );
+is( $res->return_code, 0, "mos works" );
+like( $res->output, '/MOS \d/', "Output OK" );
+
+$res = NPTest->testCmd(
+        "$sudo ./check_icmp -H $host_responsive -S 80,70 -t 2"
+        );
+is( $res->return_code, 0, "score works" );
+like( $res->output, '/Score \d/', "Output OK" );
+
+$res = NPTest->testCmd(
+        "$sudo ./check_icmp -H $host_responsive -O -t 2"
+        );
+is( $res->return_code, 0, "order works" );
+like( $res->output, '/Packets in order/', "Output OK" );
+
+$res = NPTest->testCmd(
+        "$sudo ./check_icmp -H $host_responsive -O -S 80,70 -M 4,3 -J 80,90 -P 80,90 -R 100,100 -t 2"
+        );
+is( $res->return_code, 0, "order works" );
+like( $res->output, '/Packets in order/', "Output OK" );
+like( $res->output, '/Score \d/', "Output OK" );
+like( $res->output, '/MOS \d/', "Output OK" );
+like( $res->output, '/jitter \d/', "Output OK" );
+like( $res->output, '/lost 0%/', "Output OK" );
+like( $res->output, $successOutput, "Output OK" );
diff --git a/po/de.po b/po/de.po
index 9ea32df..3a34db4 100644
--- a/po/de.po
+++ b/po/de.po
@@ -9,7 +9,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: devel@monitoring-plugins.org\n"
-"POT-Creation-Date: 2023-09-22 15:36+0200\n"
+"POT-Creation-Date: 2023-09-27 12:16+0200\n"
 "PO-Revision-Date: 2004-12-23 17:46+0100\n"
 "Last-Translator:  \n"
 "Language-Team: Monitoring Plugin Development Team <devel@monitoring-plugins."
@@ -5067,6 +5067,25 @@ msgstr "Warning threshold  Integer sein"
 msgid "critical threshold (currently "
 msgstr "Critical threshold muss ein Integer sein"
 
+msgid ""
+"RTA, round trip average,  mode  warning,critical, ex. 100ms,200ms unit in ms"
+msgstr ""
+
+msgid "packet loss mode, ex. 40%,50% , unit in %"
+msgstr ""
+
+msgid "jitter mode  warning,critical, ex. 40.000ms,50.000ms , unit in ms "
+msgstr ""
+
+msgid "MOS mode, between 0 and 4.4  warning,critical, ex. 3.5,3.0"
+msgstr ""
+
+msgid "score  mode, max value 100  warning,critical, ex. 80,70 "
+msgstr ""
+
+msgid "detect out of order ICMP packts "
+msgstr ""
+
 #, fuzzy
 msgid "specify a source IP address or device name"
 msgstr "Hostname oder Serveradresse muss angegeben werden"
@@ -5098,6 +5117,9 @@ msgstr ""
 msgid "verbose"
 msgstr ""
 
+msgid "If none of R,P,J,M,S or O is specified, default behavior is -R -P"
+msgstr ""
+
 msgid "The -H switch is optional. Naming a host (or several) to check is not."
 msgstr ""
 
diff --git a/po/fr.po b/po/fr.po
index 28deb94..da9cf19 100644
--- a/po/fr.po
+++ b/po/fr.po
@@ -10,7 +10,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: devel@monitoring-plugins.org\n"
-"POT-Creation-Date: 2023-09-22 15:36+0200\n"
+"POT-Creation-Date: 2023-09-27 12:16+0200\n"
 "PO-Revision-Date: 2010-04-21 23:38-0400\n"
 "Last-Translator: \n"
 "Language-Team: Monitoring Plugin Development Team <devel@monitoring-plugins."
@@ -5286,6 +5286,25 @@ msgstr "Valeurs pour le seuil d'avertissement (actuellement "
 msgid "critical threshold (currently "
 msgstr "Valeurs pour le seuil critique (actuellement "
 
+msgid ""
+"RTA, round trip average,  mode  warning,critical, ex. 100ms,200ms unit in ms"
+msgstr ""
+
+msgid "packet loss mode, ex. 40%,50% , unit in %"
+msgstr ""
+
+msgid "jitter mode  warning,critical, ex. 40.000ms,50.000ms , unit in ms "
+msgstr ""
+
+msgid "MOS mode, between 0 and 4.4  warning,critical, ex. 3.5,3.0"
+msgstr ""
+
+msgid "score  mode, max value 100  warning,critical, ex. 80,70 "
+msgstr ""
+
+msgid "detect out of order ICMP packts "
+msgstr ""
+
 msgid "specify a source IP address or device name"
 msgstr "spécifiez une adresse ou un nom d'hôte"
 
@@ -5316,6 +5335,9 @@ msgstr ""
 msgid "verbose"
 msgstr ""
 
+msgid "If none of R,P,J,M,S or O is specified, default behavior is -R -P"
+msgstr ""
+
 msgid "The -H switch is optional. Naming a host (or several) to check is not."
 msgstr ""
 
diff --git a/po/monitoring-plugins.pot b/po/monitoring-plugins.pot
index d019a7e..b10e73f 100644
--- a/po/monitoring-plugins.pot
+++ b/po/monitoring-plugins.pot
@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: devel@monitoring-plugins.org\n"
-"POT-Creation-Date: 2023-09-22 15:36+0200\n"
+"POT-Creation-Date: 2023-09-27 12:16+0200\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -4892,6 +4892,25 @@ msgstr ""
 msgid "critical threshold (currently "
 msgstr ""
 
+msgid ""
+"RTA, round trip average,  mode  warning,critical, ex. 100ms,200ms unit in ms"
+msgstr ""
+
+msgid "packet loss mode, ex. 40%,50% , unit in %"
+msgstr ""
+
+msgid "jitter mode  warning,critical, ex. 40.000ms,50.000ms , unit in ms "
+msgstr ""
+
+msgid "MOS mode, between 0 and 4.4  warning,critical, ex. 3.5,3.0"
+msgstr ""
+
+msgid "score  mode, max value 100  warning,critical, ex. 80,70 "
+msgstr ""
+
+msgid "detect out of order ICMP packts "
+msgstr ""
+
 msgid "specify a source IP address or device name"
 msgstr ""
 
@@ -4922,6 +4941,9 @@ msgstr ""
 msgid "verbose"
 msgstr ""
 
+msgid "If none of R,P,J,M,S or O is specified, default behavior is -R -P"
+msgstr ""
+
 msgid "The -H switch is optional. Naming a host (or several) to check is not."
 msgstr ""