LCOV - code coverage report
Current view: top level - src - cntr.c (source / functions) Hit Total Coverage
Test: burp-coverage-clean.info Lines: 139 397 35.0 %
Date: 2016-01-03 Functions: 18 36 50.0 %

          Line data    Source code
       1             : #include "burp.h"
       2             : #include "alloc.h"
       3             : #include "asfd.h"
       4             : #include "async.h"
       5             : #include "cmd.h"
       6             : #include "cntr.h"
       7             : #include "cstat.h"
       8             : #include "fsops.h"
       9             : #include "handy.h"
      10             : #include "log.h"
      11             : 
      12             : #include "server/monitor/json_output.h"
      13             : 
      14             : #include <limits.h>
      15             : 
      16             : #define CNTR_VERSION            3
      17             : #define CNTR_PATH_BUF_LEN       256
      18             : 
      19        2125 : static void cntr_ent_free_content(struct cntr_ent *cntr_ent)
      20             : {
      21        4250 :         if(!cntr_ent) return;
      22        2125 :         free_w(&cntr_ent->field);
      23        2125 :         free_w(&cntr_ent->label);
      24             : }
      25             : 
      26        2125 : static void cntr_ent_free(struct cntr_ent **cntr_ent)
      27             : {
      28        4250 :         if(!cntr_ent || !*cntr_ent) return;
      29        2125 :         cntr_ent_free_content(*cntr_ent);
      30        2125 :         free_v((void **)cntr_ent);
      31             : }
      32             : 
      33          85 : struct cntr *cntr_alloc(void)
      34             : {
      35          85 :         return (struct cntr *)calloc_w(1, sizeof(struct cntr), __func__);
      36             : }
      37             : 
      38        2125 : static int add_cntr_ent(struct cntr *cntr, int flags,
      39             :         enum cmd cmd, const char *field, const char *label)
      40             : {
      41        2125 :         struct cntr_ent *cenew=NULL;
      42        2125 :         if(!(cenew=(struct cntr_ent *)
      43        2125 :             calloc_w(1, sizeof(struct cntr_ent), __func__))
      44        2125 :           || !(cenew->field=strdup_w(field, __func__))
      45        4250 :           || !(cenew->label=strdup_w(label, __func__)))
      46             :                 goto error;
      47        2125 :         cenew->flags=flags;
      48        2125 :         cenew->cmd=cmd;
      49             : 
      50        2125 :         if(cntr->list) cenew->next=cntr->list;
      51        2125 :         cntr->list=cenew;
      52             : 
      53        2125 :         cntr->ent[(uint8_t)cmd]=cenew;
      54        2125 :         return 0;
      55             : error:
      56           0 :         cntr_ent_free(&cenew);
      57           0 :         return -1;
      58             : }
      59             : 
      60          85 : static size_t calc_max_str_len(struct cntr *cntr, const char *cname)
      61             : {
      62          85 :         size_t slen=0;
      63             :         char ullmax[64];
      64          85 :         struct cntr_ent *e=NULL;
      65             : 
      66             :         // See cntr_to_str().
      67             :         // First section - name/version/status
      68          85 :         slen+=strlen(cname);
      69          85 :         slen+=16; // More than enough space.
      70             : 
      71             :         // Second section.
      72             :         snprintf(ullmax, sizeof(ullmax),
      73             :                 " %"PRIu64 "\n", (uint64_t)ULLONG_MAX);
      74        2210 :         for(e=cntr->list; e; e=e->next)
      75             :         {
      76        2125 :                 if(e->flags & CNTR_SINGLE_FIELD)
      77             :                         // %c%llu\t
      78         765 :                         slen+=strlen(ullmax)+2;
      79             :                 else
      80             :                         // %c%llu/%llu/%llu/%llu/%llu\t
      81        1360 :                         slen+=(strlen(ullmax)*5)+6;
      82             :         }
      83             : 
      84             :         // Fourth section - a path. Cannot know how long this might be. Guess.
      85          85 :         slen+=CNTR_PATH_BUF_LEN+3; // %c%s\t\n
      86             : 
      87          85 :         slen+=1; // Terminating character.
      88             : 
      89          85 :         return slen;
      90             : }
      91             : 
      92          85 : int cntr_init(struct cntr *cntr, const char *cname)
      93             : {
      94          85 :         if(!cname)
      95             :         {
      96           0 :                 logp("%s called with no client name\n", __func__);
      97           0 :                 return -1;
      98             :         }
      99             : 
     100             :         // Add in reverse order, so that iterating over from the beginning
     101             :         // comes out in the right order.
     102          85 :         if(
     103             :              add_cntr_ent(cntr, CNTR_SINGLE_FIELD,
     104          85 :                 CMD_TIMESTAMP_END, "time_end", "End time")
     105          85 :           || add_cntr_ent(cntr, CNTR_SINGLE_FIELD,
     106          85 :                 CMD_TIMESTAMP, "time_start", "Start time")
     107          85 :           || add_cntr_ent(cntr, CNTR_SINGLE_FIELD,
     108          85 :                 CMD_BYTES_SENT, "bytes_sent", "Bytes sent")
     109          85 :           || add_cntr_ent(cntr, CNTR_SINGLE_FIELD,
     110          85 :                 CMD_BYTES_RECV, "bytes_received", "Bytes received")
     111          85 :           || add_cntr_ent(cntr, CNTR_SINGLE_FIELD,
     112          85 :                 CMD_BYTES, "bytes", "Bytes")
     113          85 :           || add_cntr_ent(cntr, CNTR_SINGLE_FIELD,
     114          85 :                 CMD_BYTES_ESTIMATED, "bytes_estimated", "Bytes estimated")
     115          85 :           || add_cntr_ent(cntr, CNTR_SINGLE_FIELD,
     116          85 :                 CMD_MESSAGE, "messages", "Messages")
     117          85 :           || add_cntr_ent(cntr, CNTR_SINGLE_FIELD,
     118          85 :                 CMD_WARNING, "warnings", "Warnings")
     119          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     120          85 :                 CMD_GRAND_TOTAL, "grand_total", "Grand total")
     121          85 :           || add_cntr_ent(cntr, 0,
     122          85 :                 CMD_TOTAL, "total", "Total")
     123          85 :           || add_cntr_ent(cntr, CNTR_SINGLE_FIELD,
     124          85 :                 CMD_ERROR, "errors", "Errors")
     125          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     126          85 :                 CMD_DATA, "blocks", "Blocks")
     127          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     128          85 :                 CMD_EFS_FILE, "efs_files", "EFS files")
     129          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     130          85 :                 CMD_ENC_VSS_T, "vss_footers_encrypted", "VSS footers (enc)")
     131          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     132          85 :                 CMD_VSS_T, "vss_footers", "VSS footers")
     133          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     134          85 :                 CMD_ENC_VSS, "vss_headers_encrypted", "VSS headers (enc)")
     135          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     136          85 :                 CMD_VSS, "vss_headers", "VSS headers")
     137          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     138          85 :                 CMD_SPECIAL, "special_files", "Special files")
     139          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     140          85 :                 CMD_SOFT_LINK, "hard_links", "Soft links")
     141          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     142          85 :                 CMD_HARD_LINK, "soft_links", "Hard links")
     143          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     144          85 :                 CMD_DIRECTORY, "directories", "Directories")
     145          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     146          85 :                 CMD_ENC_METADATA, "meta_data_encrypted", "Meta data (enc)")
     147          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     148          85 :                 CMD_METADATA, "meta_data", "Meta data")
     149          85 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     150          85 :                 CMD_ENC_FILE, "files_encrypted", "Files (encrypted)")
     151         170 :           || add_cntr_ent(cntr, CNTR_TABULATE,
     152          85 :                 CMD_FILE, "files", "Files")
     153             :         )
     154             :                 return -1;
     155             : 
     156          85 :         cntr->ent[(uint8_t)CMD_TIMESTAMP]->count=(uint64_t)time(NULL);
     157             : 
     158          85 :         cntr->str_max_len=calc_max_str_len(cntr, cname);
     159         170 :         if(!(cntr->str=(char *)calloc_w(1, cntr->str_max_len, __func__))
     160          85 :           || !(cntr->cname=strdup_w(cname, __func__)))
     161             :                 return -1;
     162             : 
     163          85 :         return 0;
     164             : }
     165             : 
     166          85 : static void cntr_free_content(struct cntr *cntr)
     167             : {
     168             :         struct cntr_ent *e;
     169          85 :         struct cntr_ent *l=NULL;
     170        2210 :         for(e=cntr->list; e; e=l)
     171             :         {
     172        2125 :                 l=e->next;
     173        2125 :                 cntr_ent_free(&e);
     174             :         }
     175          85 :         cntr->list=NULL;
     176          85 :         free_w(&cntr->str);
     177          85 :         free_w(&cntr->cname);
     178          85 : }
     179             : 
     180         215 : void cntr_free(struct cntr **cntr)
     181             : {
     182         430 :         if(!cntr || !*cntr) return;
     183          85 :         cntr_free_content(*cntr);
     184          85 :         free_v((void **)cntr);
     185             : }
     186             : 
     187           2 : const char *bytes_to_human(uint64_t counter)
     188             : {
     189             :         static char ret[32]="";
     190           2 :         float div=(float)counter;
     191           2 :         char units[3]="";
     192             : 
     193           2 :         if(div<1024) return "";
     194             : 
     195           0 :         if((div/=1024)<1024)
     196             :                 snprintf(units, sizeof(units), "KB");
     197           0 :         else if((div/=1024)<1024)
     198             :                 snprintf(units, sizeof(units), "MB");
     199           0 :         else if((div/=1024)<1024)
     200             :                 snprintf(units, sizeof(units), "GB");
     201           0 :         else if((div/=1024)<1024)
     202             :                 snprintf(units, sizeof(units), "TB");
     203           0 :         else if((div/=1024)<1024)
     204             :                 snprintf(units, sizeof(units), "EB");
     205             :         else
     206             :         {
     207           0 :                 div/=1024;
     208             :                 snprintf(units, sizeof(units), "PB");
     209             :         }
     210           0 :         snprintf(ret, sizeof(ret), " (%.2f %s)", div, units);
     211           0 :         return ret;
     212             : }
     213             : 
     214             : static void border(void)
     215             : {
     216           0 :         logc("--------------------------------------------------------------------------------\n");
     217             : }
     218             : 
     219           0 : static void table_border(enum action act)
     220             : {
     221           0 :         if(act==ACTION_BACKUP
     222           0 :           || act==ACTION_BACKUP_TIMED)
     223             :         {
     224           0 :           logc("% 18s ------------------------------------------------------------\n", "");
     225             :         }
     226           0 :         if(act==ACTION_RESTORE
     227           0 :           || act==ACTION_VERIFY)
     228             :         {
     229           0 :           logc("% 18s ------------------------------\n", "");
     230             :         }
     231           0 : }
     232             : 
     233             : static void incr_count_val(struct cntr *cntr, char ch, uint64_t val)
     234             : {
     235       10035 :         if(!cntr) return;
     236           0 :         if(cntr->ent[(uint8_t)ch]) cntr->ent[(uint8_t)ch]->count+=val;
     237             : }
     238             : 
     239             : static void incr_same_val(struct cntr *cntr, char ch, uint64_t val)
     240             : {
     241       30258 :         if(!cntr) return;
     242           0 :         if(cntr->ent[(uint8_t)ch]) cntr->ent[(uint8_t)ch]->same+=val;
     243             : }
     244             : 
     245             : static void incr_changed_val(struct cntr *cntr, char ch, uint64_t val)
     246             : {
     247          12 :         if(!cntr) return;
     248           0 :         if(cntr->ent[(uint8_t)ch]) cntr->ent[(uint8_t)ch]->changed+=val;
     249             : }
     250             : 
     251             : static void incr_deleted_val(struct cntr *cntr, char ch, uint64_t val)
     252             : {
     253           0 :         if(!cntr) return;
     254           0 :         if(cntr->ent[(uint8_t)ch]) cntr->ent[(uint8_t)ch]->deleted+=val;
     255             : }
     256             : 
     257             : static void incr_phase1_val(struct cntr *cntr, char ch, uint64_t val)
     258             : {
     259           0 :         if(!cntr) return;
     260           0 :         if(cntr->ent[(uint8_t)ch]) cntr->ent[(uint8_t)ch]->phase1+=val;
     261             : }
     262             : 
     263             : static void incr_count(struct cntr *cntr, char ch)
     264             : {
     265           0 :         return incr_count_val(cntr, ch, 1);
     266             : }
     267             : 
     268             : static void incr_same(struct cntr *cntr, char ch)
     269             : {
     270       30258 :         return incr_same_val(cntr, ch, 1);
     271             : }
     272             : 
     273             : static void incr_changed(struct cntr *cntr, char ch)
     274             : {
     275          12 :         return incr_changed_val(cntr, ch, 1);
     276             : }
     277             : 
     278             : static void incr_deleted(struct cntr *cntr, char ch)
     279             : {
     280           0 :         return incr_deleted_val(cntr, ch, 1);
     281             : }
     282             : 
     283             : static void incr_phase1(struct cntr *cntr, char ch)
     284             : {
     285           0 :         return incr_phase1_val(cntr, ch, 1);
     286             : }
     287             : 
     288             : static void print_end(uint64_t val)
     289             : {
     290           0 :         if(val) logc(" %"PRIu64 "\n", val);
     291             : }
     292             : 
     293       10133 : void cntr_add(struct cntr *c, char ch, int print)
     294             : {
     295             :         struct cntr_ent *grand_total_ent;
     296       10133 :         if(!c) return;
     297           0 :         if(!(grand_total_ent=c->ent[CMD_GRAND_TOTAL])) return;
     298           0 :         if(print)
     299             :         {
     300           0 :                 if(ch!=CMD_MESSAGE && ch!=CMD_WARNING)
     301           0 :                         logc("%c", ch);
     302             :         }
     303           0 :         if(ch==CMD_FILE_CHANGED)
     304             :         {
     305             :                 incr_changed(c, CMD_FILE);
     306             :                 incr_changed(c, CMD_TOTAL);
     307             :                 incr_changed(c, CMD_GRAND_TOTAL);
     308             :         }
     309             :         else
     310             :         {
     311           0 :                 incr_count(c, ch);
     312           0 :                 if(ch==CMD_WARNING || ch==CMD_MESSAGE) return;
     313             :                 incr_count(c, CMD_TOTAL);
     314             :         }
     315             : 
     316           0 :         if(!((++grand_total_ent->count)%64) && print)
     317           0 :                 print_end(grand_total_ent->count);
     318           0 :         fflush(stdout);
     319             : }
     320             : 
     321           0 : void cntr_add_phase1(struct cntr *c, char ch, int print)
     322             : {
     323             :         static struct cntr_ent *total;
     324           0 :         incr_phase1(c, ch);
     325             : 
     326           0 :         total=c->ent[(uint8_t)CMD_GRAND_TOTAL];
     327           0 :         ++total->phase1;
     328           0 :         if(!print) return;
     329           0 :         if(total->phase1==1) logc("\n");
     330           0 :         logc("%c", ch);
     331           0 :         if(!((total->phase1)%64))
     332           0 :                 print_end(total->phase1);
     333           0 :         fflush(stdout);
     334             : }
     335             : 
     336           0 : void cntr_add_val(struct cntr *c, char ch, uint64_t val, int print)
     337             : {
     338           0 :         incr_count_val(c, ch, val);
     339           0 : }
     340             : 
     341       10086 : void cntr_add_same(struct cntr *c, char ch)
     342             : {
     343       10086 :         incr_same(c, ch);
     344             :         incr_same(c, CMD_TOTAL);
     345             :         incr_same(c, CMD_GRAND_TOTAL);
     346       10086 : }
     347             : 
     348           0 : void cntr_add_same_val(struct cntr *c, char ch, uint64_t val)
     349             : {
     350           0 :         incr_same_val(c, ch, val);
     351             :         incr_same_val(c, CMD_TOTAL, val);
     352             :         incr_same_val(c, CMD_GRAND_TOTAL, val);
     353           0 : }
     354             : 
     355           4 : void cntr_add_changed(struct cntr *c, char ch)
     356             : {
     357           4 :         incr_changed(c, ch);
     358             :         incr_changed(c, CMD_TOTAL);
     359             :         incr_changed(c, CMD_GRAND_TOTAL);
     360           4 : }
     361             : 
     362           0 : void cntr_add_changed_val(struct cntr *c, char ch, uint64_t val)
     363             : {
     364           0 :         incr_changed_val(c, ch, val);
     365             :         incr_changed_val(c, CMD_TOTAL, val);
     366             :         incr_changed_val(c, CMD_GRAND_TOTAL, val);
     367           0 : }
     368             : 
     369           0 : void cntr_add_deleted(struct cntr *c, char ch)
     370             : {
     371           0 :         incr_deleted(c, ch);
     372             :         incr_deleted(c, CMD_TOTAL);
     373             :         incr_deleted(c, CMD_GRAND_TOTAL);
     374           0 : }
     375             : 
     376          20 : void cntr_add_bytes(struct cntr *c, uint64_t bytes)
     377             : {
     378             :         incr_count_val(c, CMD_BYTES, bytes);
     379          20 : }
     380             : 
     381          15 : void cntr_add_sentbytes(struct cntr *c, uint64_t bytes)
     382             : {
     383             :         incr_count_val(c, CMD_BYTES_SENT, bytes);
     384          15 : }
     385             : 
     386       10000 : void cntr_add_recvbytes(struct cntr *c, uint64_t bytes)
     387             : {
     388             :         incr_count_val(c, CMD_BYTES_RECV, bytes);
     389       10000 : }
     390             : 
     391           0 : static void quint_print(struct cntr_ent *ent, enum action act)
     392             : {
     393             :         uint64_t a;
     394             :         uint64_t b;
     395             :         uint64_t c;
     396             :         uint64_t d;
     397             :         uint64_t e;
     398           0 :         if(!ent) return;
     399           0 :         a=ent->count;
     400           0 :         b=ent->changed;
     401           0 :         c=ent->same;
     402           0 :         d=ent->deleted;
     403           0 :         e=ent->phase1;
     404             : 
     405           0 :         if(!(ent->flags & CNTR_TABULATE)) return;
     406             : 
     407           0 :         if(!e && !a && !b && !c) return;
     408           0 :         logc("% 18s:", ent->label);
     409           0 :         if(act==ACTION_BACKUP
     410           0 :           || act==ACTION_BACKUP_TIMED)
     411             :         {
     412           0 :                 logc("% 9llu ", a);
     413           0 :                 logc("% 9llu ", b);
     414           0 :                 logc("% 9llu ", c);
     415           0 :                 logc("% 9llu ", d);
     416             :         }
     417           0 :         if(act==ACTION_RESTORE
     418           0 :           || act==ACTION_VERIFY)
     419             :         {
     420           0 :                 logc("% 9s ", "");
     421             :                 //logc("% 9s ", "");
     422             :                 //logc("% 9s ", "");
     423             :                 //logc("% 9s ", "");
     424             :         }
     425           0 :         if(act==ACTION_ESTIMATE)
     426             :         {
     427           0 :                 logc("% 9s ", "");
     428           0 :                 logc("% 9s ", "");
     429           0 :                 logc("% 9llu\n", e);
     430             :         }
     431             :         else
     432             :         {
     433           0 :                 logc("% 9llu |", a+b+c);
     434           0 :                 logc("% 9llu\n", e);
     435             :         }
     436             : }
     437             : 
     438             : static uint64_t get_count(struct cntr_ent **ent, enum cmd cmd)
     439             : {
     440           0 :         if(!ent[(uint8_t)cmd]) return 0;
     441           0 :         return ent[(uint8_t)cmd]->count;
     442             : }
     443             : 
     444           0 : static void bottom_part(struct cntr *c, enum action act)
     445             : {
     446             :         uint64_t l;
     447           0 :         struct cntr_ent **e=c->ent;
     448           0 :         logc("\n");
     449           0 :         logc("             Messages:   % 11llu\n", get_count(e, CMD_MESSAGE));
     450           0 :         logc("             Warnings:   % 11llu\n", get_count(e, CMD_WARNING));
     451           0 :         logc("\n");
     452           0 :         logc("      Bytes estimated:   % 11llu", get_count(e, CMD_BYTES_ESTIMATED));
     453           0 :         logc("%s\n", bytes_to_human(get_count(e, CMD_BYTES_ESTIMATED)));
     454             : 
     455           0 :         if(act==ACTION_ESTIMATE) return;
     456             : 
     457           0 :         if(act==ACTION_BACKUP
     458           0 :           || act==ACTION_BACKUP_TIMED)
     459             :         {
     460           0 :                 l=get_count(e, CMD_BYTES);
     461           0 :                 logc("      Bytes in backup:   % 11llu", l);
     462           0 :                 logc("%s\n", bytes_to_human(l));
     463             :         }
     464           0 :         if(act==ACTION_RESTORE)
     465             :         {
     466           0 :                 l=get_count(e, CMD_BYTES);
     467           0 :                 logc("      Bytes attempted:   % 11llu", l);
     468           0 :                 logc("%s\n", bytes_to_human(l));
     469             :         }
     470           0 :         if(act==ACTION_VERIFY)
     471             :         {
     472           0 :                 l=get_count(e, CMD_BYTES);
     473           0 :                 logc("        Bytes checked:   % 11llu", l);
     474           0 :                 logc("%s\n", bytes_to_human(l));
     475             :         }
     476             : 
     477           0 :         if(act==ACTION_BACKUP
     478             :           || act==ACTION_BACKUP_TIMED)
     479             :         {
     480           0 :                 l=get_count(e, CMD_BYTES_RECV);
     481           0 :                 logc("       Bytes received:   % 11llu", l);
     482           0 :                 logc("%s\n", bytes_to_human(l));
     483             :         }
     484           0 :         if(act==ACTION_BACKUP 
     485             :           || act==ACTION_BACKUP_TIMED
     486           0 :           || act==ACTION_RESTORE)
     487             :         {
     488           0 :                 l=get_count(e, CMD_BYTES_SENT);
     489           0 :                 logc("           Bytes sent:   % 11llu", l);
     490           0 :                 logc("%s\n", bytes_to_human(l));
     491             :         }
     492             : }
     493             : 
     494          27 : void cntr_print(struct cntr *cntr, enum action act)
     495             : {
     496             :         struct cntr_ent *e;
     497             :         time_t now;
     498             :         time_t start;
     499          54 :         if(!cntr) return;
     500           0 :         now=time(NULL);
     501           0 :         start=(time_t)cntr->ent[(uint8_t)CMD_TIMESTAMP]->count;
     502           0 :         cntr->ent[(uint8_t)CMD_TIMESTAMP_END]->count=(uint64_t)now;
     503             : 
     504             :         border();
     505           0 :         logc("Start time: %s\n", getdatestr(start));
     506           0 :         logc("  End time: %s\n", getdatestr(now));
     507           0 :         logc("Time taken: %s\n", time_taken(now-start));
     508           0 :         if(act==ACTION_BACKUP
     509           0 :           || act==ACTION_BACKUP_TIMED)
     510             :         {
     511             :           logc("% 18s % 9s % 9s % 9s % 9s % 9s |% 9s\n",
     512           0 :             " ", "New", "Changed", "Unchanged", "Deleted", "Total", "Scanned");
     513             :         }
     514           0 :         if(act==ACTION_RESTORE
     515           0 :           || act==ACTION_VERIFY)
     516             :         {
     517             :           logc("% 18s % 9s % 9s |% 9s\n",
     518           0 :             " ", "", "Attempted", "Expected");
     519             :         }
     520           0 :         if(act==ACTION_ESTIMATE)
     521             :         {
     522             :           logc("% 18s % 9s % 9s %9s\n",
     523           0 :             " ", "", "", "Scanned");
     524             :         }
     525           0 :         table_border(act);
     526             : 
     527           0 :         for(e=cntr->list; e; e=e->next)
     528           0 :                 quint_print(e, act);
     529             : 
     530           0 :         table_border(act);
     531           0 :         bottom_part(cntr, act);
     532             : 
     533             :         border();
     534             : }
     535             : 
     536             : #ifndef HAVE_WIN32
     537             : 
     538           5 : int cntr_stats_to_file(struct cntr *cntr,
     539             :         const char *directory, enum action act, struct conf **confs)
     540             : {
     541           5 :         int ret=-1;
     542           5 :         int fd=-1;
     543           5 :         char *path=NULL;
     544           5 :         const char *fname=NULL;
     545           5 :         struct async *as=NULL;
     546           5 :         struct asfd *wfd=NULL;
     547           5 :         if(!cntr)
     548             :                 return 0;
     549           0 :         cntr->ent[(uint8_t)CMD_TIMESTAMP_END]->count
     550           0 :                 =(uint64_t)time(NULL);
     551             : 
     552           0 :         if(act==ACTION_BACKUP
     553           0 :           ||  act==ACTION_BACKUP_TIMED)
     554             :                 fname="backup_stats";
     555           0 :         else if(act==ACTION_RESTORE)
     556             :                 fname="restore_stats";
     557           0 :         else if(act==ACTION_VERIFY)
     558             :                 fname="verify_stats";
     559             :         else
     560             :                 return 0;
     561             : 
     562           0 :         if(!(path=prepend_s(directory, fname)))
     563             :                 goto end;
     564           0 :         if((fd=open(path, O_WRONLY|O_CREAT, 0666))<0)
     565             :         {
     566             :                 logp("Could not open %s for writing in %s: %s\n",
     567           0 :                         path, __func__, strerror(errno));
     568           0 :                 goto end;
     569             :         }
     570             :         // FIX THIS:
     571             :         // Pretty heavy duty to set up all this async stuff just so that the
     572             :         // json stuff can write to a simple file.
     573           0 :         if(!(as=async_alloc())
     574           0 :           || as->init(as, 0)
     575           0 :           || !(wfd=asfd_alloc())
     576           0 :           || wfd->init(wfd, "stats file",
     577           0 :                 as, fd, NULL, ASFD_STREAM_LINEBUF, confs))
     578             :                         goto end;
     579           0 :         as->asfd_add(as, wfd);
     580           0 :         fd=-1;
     581           0 :         if(json_cntr_to_file(wfd, cntr))
     582             :                 goto end;
     583             : 
     584             : // FIX THIS: make this use the json output stuff.
     585             : // Need to add the following few fields to the cntrs somehow.
     586             : /*
     587             :         fprintf(fp, "client_version:%s\n",
     588             :                 conf->peer_version?conf->peer_version:"");
     589             :         fprintf(fp, "server_version:%s\n", VERSION);
     590             :         fprintf(fp, "client_is_windows:%d\n", conf->client_is_windows);
     591             :         for(e=cntr->list; e; e=e->next)
     592             :                 quint_print_to_file(fp, e, act);
     593             : */
     594             : 
     595           0 :         ret=0;
     596             : end:
     597           0 :         close_fd(&fd);
     598           0 :         free_w(&path);
     599           0 :         async_free(&as);
     600           0 :         asfd_free(&wfd);
     601           0 :         return ret;
     602             : }
     603             : 
     604             : #endif
     605             : 
     606          22 : void cntr_print_end(struct cntr *cntr)
     607             : {
     608             :         struct cntr_ent *grand_total_ent;
     609          44 :         if(!cntr) return;
     610           0 :         grand_total_ent=cntr->ent[CMD_GRAND_TOTAL];
     611           0 :         if(grand_total_ent)
     612             :         {
     613           0 :                 print_end(grand_total_ent->count);
     614           0 :                 logc("\n");
     615             :         }
     616             : }
     617             : 
     618           0 : void cntr_print_end_phase1(struct cntr *cntr)
     619             : {
     620             :         struct cntr_ent *grand_total_ent;
     621           0 :         if(!cntr) return;
     622           0 :         grand_total_ent=cntr->ent[CMD_GRAND_TOTAL];
     623           0 :         if(grand_total_ent)
     624             :         {
     625           0 :                 print_end(grand_total_ent->phase1);
     626           0 :                 logc("\n");
     627             :         }
     628             : }
     629             : 
     630             : #ifndef HAVE_WIN32
     631             : // Return string length.
     632           0 : size_t cntr_to_str(struct cntr *cntr, const char *path)
     633             : {
     634             :         static char tmp[CNTR_PATH_BUF_LEN+3]="";
     635           0 :         struct cntr_ent *e=NULL;
     636           0 :         char *str=cntr->str;
     637             : 
     638           0 :         cntr->ent[(uint8_t)CMD_TIMESTAMP_END]->count=time(NULL);
     639             : 
     640             :         snprintf(str, cntr->str_max_len-1, "%s\t%d\t%d\t",
     641           0 :                 cntr->cname, CNTR_VERSION, cntr->cntr_status);
     642             : 
     643           0 :         for(e=cntr->list; e; e=e->next)
     644             :         {
     645           0 :                 if(e->flags & CNTR_SINGLE_FIELD)
     646             :                         snprintf(tmp, sizeof(tmp),
     647           0 :                                 "%c%"PRIu64"\t", e->cmd, e->count);
     648             :                 else
     649             :                         snprintf(tmp, sizeof(tmp),
     650             :                         "%c%"PRIu64"/%"PRIu64"/%"PRIu64"/%"PRIu64"/%"PRIu64"\t",
     651             :                                 e->cmd, e->count, e->same,
     652           0 :                                 e->changed, e->deleted, e->phase1);
     653             :                 strcat(str, tmp);
     654             :         }
     655             : 
     656             :         // Abuse CMD_DATAPTH.
     657           0 :         snprintf(tmp, sizeof(tmp), "%c%s\t\n", CMD_DATAPTH, path?path:"");
     658             :         strcat(str, tmp);
     659             : 
     660           0 :         return strlen(str);
     661             : }
     662             : #endif
     663             : 
     664           0 : static int extract_ul(const char *value, struct cntr_ent *ent)
     665             : {
     666           0 :         char *as=NULL;
     667           0 :         char *bs=NULL;
     668           0 :         char *cs=NULL;
     669           0 :         char *ds=NULL;
     670           0 :         char *es=NULL;
     671           0 :         char *copy=NULL;
     672           0 :         if(!value || !(copy=strdup_w(value, __func__))) return -1;
     673             : 
     674             :         // Do not want to use strtok, just in case I end up running more
     675             :         // than one at a time.
     676           0 :         as=copy;
     677           0 :         if((bs=strchr(as, '/')))
     678             :         {
     679           0 :                 *bs='\0';
     680           0 :                 ent->count=strtoull(as, NULL, 10);
     681           0 :                 if((cs=strchr(++bs, '/')))
     682             :                 {
     683           0 :                         *cs='\0';
     684           0 :                         ent->changed=strtoull(bs, NULL, 10);
     685           0 :                         if((ds=strchr(++cs, '/')))
     686             :                         {
     687           0 :                                 *ds='\0';
     688           0 :                                 ent->same=strtoull(cs, NULL, 10);
     689           0 :                                 if((es=strchr(++ds, '/')))
     690             :                                 {
     691           0 :                                         ent->deleted=strtoull(ds, NULL, 10);
     692           0 :                                         *es='\0';
     693           0 :                                         es++;
     694           0 :                                         ent->phase1=strtoull(es, NULL, 10);
     695             :                                 }
     696             :                         }
     697             :                 }
     698             :         }
     699             :         else
     700             :         {
     701             :                 // Single field.
     702           0 :                 ent->count=strtoull(as, NULL, 10);
     703             :         }
     704           0 :         free_w(&copy);
     705           0 :         return 0;
     706             : }
     707             : 
     708             : /*
     709             : static char *get_backup_str(const char *s, int *deletable)
     710             : {
     711             :         static char str[32]="";
     712             :         const char *cp=NULL;
     713             :         const char *dp=NULL;
     714             :         if(!s || !*s) return NULL;
     715             :         if(!(cp=strchr(s, ' '))
     716             :           || !(dp=strchr(cp+1, ' ')))
     717             :                 snprintf(str, sizeof(str), "never");
     718             :         else
     719             :         {
     720             :                 uint64_t backupnum=0;
     721             :                 backupnum=strtoul(s, NULL, 10);
     722             :                 snprintf(str, sizeof(str),
     723             :                         "%07lu %s", backupnum, getdatestr(atol(dp+1)));
     724             :                 if(*(cp+1)=='1') *deletable=1;
     725             :         }
     726             :         return str;
     727             : }
     728             : */
     729             : 
     730             : /*
     731             : static int add_to_backup_list(struct strlist **backups, const char *tok)
     732             : {
     733             :         int deletable=0;
     734             :         const char *str=NULL;
     735             :         if(!(str=get_backup_str(tok, &deletable))) return 0;
     736             :         if(strlist_add(backups, (char *)str, deletable)) return -1;
     737             :         return 0;
     738             : }
     739             : */
     740             : 
     741           0 : static int extract_cntrs(struct cstat *cstat, char **path)
     742             : {
     743             :         char *tok;
     744           0 :         struct cntr *cntr=cstat->cntr;
     745           0 :         while((tok=strtok(NULL, "\t\n")))
     746             :         {
     747           0 :                 switch(tok[0])
     748             :                 {
     749             :                         case CMD_DATAPTH:
     750           0 :                                 free_w(path);
     751           0 :                                 if(!(*path=strdup_w(tok+1, __func__)))
     752             :                                         return -1;
     753             :                                 break;
     754             :                         default:
     755           0 :                                 if(cntr->ent[(uint8_t)tok[0]]
     756           0 :                                   && extract_ul(tok+1,
     757           0 :                                         cntr->ent[(uint8_t)tok[0]]))
     758             :                                                 return -1;
     759             :                                 break;
     760             :                 }
     761             :         }
     762             :         return 0;
     763             : }
     764             : 
     765           0 : int str_to_cntr(const char *str, struct cstat *cstat, char **path)
     766             : {
     767           0 :         int ret=-1;
     768           0 :         char *tok=NULL;
     769           0 :         char *copy=NULL;
     770             : 
     771           0 :         if(!(copy=strdup_w(str, __func__)))
     772             :                 return -1;
     773             : 
     774           0 :         if((tok=strtok(copy, "\t\n")))
     775             :         {
     776           0 :                 char *tmp=NULL;
     777             :                 // First token is the client name. Do not need that here.
     778             :                 // Second is the cntr version.
     779           0 :                 if(!(tmp=strtok(NULL, "\t\n")))
     780             :                 {
     781             :                         logp("Parsing problem in %s: null version\n",
     782           0 :                                 __func__);
     783           0 :                         goto end;
     784             :                 }
     785           0 :                 if(atoi(tmp)!=CNTR_VERSION)
     786             :                 {
     787             :                         ret=0;
     788             :                         goto end;
     789             :                 }
     790             :                 // Third is cstat_status.
     791           0 :                 if(!(tmp=strtok(NULL, "\t\n")))
     792             :                 {
     793             :                         logp("Parsing problem in %s: null cstat_status\n",
     794           0 :                                 __func__);
     795           0 :                         goto end;
     796             :                 }
     797           0 :                 cstat->cntr->cntr_status=(enum cntr_status)atoi(tmp);
     798             : 
     799           0 :                 if(extract_cntrs(cstat, path)) goto end;
     800             :         }
     801             : 
     802             :         ret=0;
     803             : end:
     804           0 :         free_w(&copy);
     805           0 :         return ret;
     806             : }
     807             : 
     808             : #ifndef HAVE_WIN32
     809           0 : int cntr_send(struct cntr *cntr)
     810             : {
     811             : /*
     812             :         size_t l;
     813             :         char buf[4096]="";
     814             :         l=cntr_to_str(get_cntr(confs[OPT_CNTR]), STATUS_RUNNING, " ");
     815             :         if(async_write_strn(CMD_GEN, buf, l))
     816             :         {
     817             :                 logp("Error when sending counters to client.\n");
     818             :                 return -1;
     819             :         }
     820             : */
     821           0 :         return 0;
     822             : }
     823             : #endif
     824             : 
     825           0 : static enum asl_ret cntr_recv_func(struct asfd *asfd,
     826             :         struct conf **confs, void *param)
     827             : {
     828             : /*
     829             :         if(str_to_cntr(asfd->rbuf->buf, NULL, NULL, NULL, NULL,
     830             :                 conf->p1cntr, get_cntr(confs[OPT_CNTR]), NULL))
     831             :                         return ASL_END_ERROR;
     832             : */
     833           0 :         return ASL_END_OK;
     834             : }
     835             : 
     836           0 : int cntr_recv(struct asfd *asfd, struct conf **confs)
     837             : {
     838           0 :         return asfd->simple_loop(asfd, confs, NULL, __func__, cntr_recv_func);
     839             : }
     840             : 
     841           0 : const char *cntr_status_to_str(struct cntr *cntr)
     842             : {
     843           0 :         switch(cntr->cntr_status)
     844             :         {
     845             :                 case CNTR_STATUS_SCANNING: return CNTR_STATUS_STR_SCANNING;
     846             :                 case CNTR_STATUS_BACKUP: return CNTR_STATUS_STR_BACKUP;
     847             :                 case CNTR_STATUS_MERGING: return CNTR_STATUS_STR_MERGING;
     848             :                 case CNTR_STATUS_SHUFFLING: return CNTR_STATUS_STR_SHUFFLING;
     849             :                 case CNTR_STATUS_LISTING: return CNTR_STATUS_STR_LISTING;
     850             :                 case CNTR_STATUS_RESTORING: return CNTR_STATUS_STR_RESTORING;
     851             :                 case CNTR_STATUS_VERIFYING: return CNTR_STATUS_STR_VERIFYING;
     852             :                 case CNTR_STATUS_DELETING: return CNTR_STATUS_STR_DELETING;
     853             :                 case CNTR_STATUS_DIFFING: return CNTR_STATUS_STR_DIFFING;
     854             :                 default: return "unknown";
     855             :         }
     856             : }
     857             : 
     858           0 : enum cntr_status cntr_str_to_status(const char *str)
     859             : {
     860           0 :         if(!strcmp(str, CNTR_STATUS_STR_SCANNING))
     861             :                 return CNTR_STATUS_SCANNING;
     862           0 :         else if(!strcmp(str, CNTR_STATUS_STR_BACKUP))
     863             :                 return CNTR_STATUS_BACKUP;
     864           0 :         else if(!strcmp(str, CNTR_STATUS_STR_MERGING))
     865             :                 return CNTR_STATUS_MERGING;
     866           0 :         else if(!strcmp(str, CNTR_STATUS_STR_SHUFFLING))
     867             :                 return CNTR_STATUS_SHUFFLING;
     868           0 :         else if(!strcmp(str, CNTR_STATUS_STR_LISTING))
     869             :                 return CNTR_STATUS_LISTING;
     870           0 :         else if(!strcmp(str, CNTR_STATUS_STR_RESTORING))
     871             :                 return CNTR_STATUS_RESTORING;
     872           0 :         else if(!strcmp(str, CNTR_STATUS_STR_VERIFYING))
     873             :                 return CNTR_STATUS_VERIFYING;
     874           0 :         else if(!strcmp(str, CNTR_STATUS_STR_DELETING))
     875             :                 return CNTR_STATUS_DELETING;
     876           0 :         else if(!strcmp(str, CNTR_STATUS_STR_DIFFING))
     877             :                 return CNTR_STATUS_DIFFING;
     878           0 :         return CNTR_STATUS_UNSET;
     879             : }

Generated by: LCOV version 1.10