开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
versioncheck.c
资源名称：pvpgn-1.6.2.rar　[点击查看]
上传用户：tany51
上传日期：2013-06-12
资源大小：1397k
文件大小：22k
源码类别：

MySQL数据库

开发平台：

Visual C++

versioncheck.c：源码内容
  1. /*
  2.  * Copyright (C) 2000 Onlyer (onlyer@263.net)
  3.  * Copyright (C) 2001 Ross Combs (ross@bnetd.org)
  4.  * Copyright (C) 2002 Gianluigi Tiesi (sherpya@netfarm.it)
  5.  *
  6.  * This program is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU General Public License
  8.  * as published by the Free Software Foundation; either version 2
  9.  * of the License, or (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  */
  20. #define VERSIONCHECK_INTERNAL_ACCESS
  21. #include "common/setup_before.h"
  22. #include <stdio.h>
  23. #ifdef HAVE_STDDEF_H
  24. # include <stddef.h>
  25. #else
  26. # ifndef NULL
  27. #  define NULL ((void *)0)
  28. # endif
  29. #endif
  30. #ifdef STDC_HEADERS
  31. # include <stdlib.h>
  32. #else
  33. # ifdef HAVE_MALLOC_H
  34. #  include <malloc.h>
  35. # endif
  36. #endif
  37. #include "compat/strtoul.h"
  38. #ifdef HAVE_STRING_H
  39. # include <string.h>
  40. #else
  41. # ifdef HAVE_STRINGS_H
  42. #  include <strings.h>
  43. # endif
  44. #endif
  45. #ifdef HAVE_MKTIME
  46. # ifdef TIME_WITH_SYS_TIME
  47. #  include <sys/time.h>
  48. #  include <time.h>
  49. # else
  50. #  ifdef HAVE_SYS_TIME_H
  51. #   include <sys/time.h>
  52. #  else
  53. #   include <time.h>
  54. #  endif
  55. # endif
  56. #endif
  57. #include "compat/strchr.h"
  58. #include "compat/strdup.h"
  59. #include "compat/strcasecmp.h"
  60. #include <ctype.h>
  61. #include <errno.h>
  62. #include "compat/strerror.h"
  63. #include "common/eventlog.h"
  64. #include "common/list.h"
  65. #include "common/util.h"
  66. #include "common/proginfo.h"
  67. #include "common/token.h"
  68. #include "common/field_sizes.h"
  69. #include "prefs.h"
  70. #include "versioncheck.h"
  71. #include "common/setup_after.h"
  74. static t_list * versioninfo_head=NULL;
  75. static t_versioncheck dummyvc={ "A=42 B=42 C=42 4 A=A^S B=B^B C=C^C A=A^S", "IX86ver1.mpq", "NoVC" };
  77. static int versioncheck_compare_exeinfo(t_parsed_exeinfo * pattern, t_parsed_exeinfo * match);
  79. extern t_versioncheck * versioncheck_create(char const * archtag, char const * clienttag)
  80. {
  81.     t_elem const *   curr;
  82.     t_versioninfo *  vi;
  83.     t_versioncheck * vc;
  84.     
  85.     LIST_TRAVERSE_CONST(versioninfo_head,curr)
  86.     {
  87.         if (!(vi = elem_get_data(curr))) /* should not happen */
  88.         {
  89.             eventlog(eventlog_level_error,"versioncheck_create","version list contains NULL item");
  90.             continue;
  91.         }
  93. eventlog(eventlog_level_debug,"versioncheck_create","version check entry archtag=%s, clienttag=%s",vi->archtag,vi->clienttag);
  94. if (strcmp(vi->archtag,archtag)!=0)
  95.     continue;
  96. if (strcmp(vi->clienttag,clienttag)!=0)
  97.     continue;
  99. /* FIXME: randomize the selection if more than one match */
  100. if (!(vc = malloc(sizeof(t_versioncheck))))
  101. {
  102.     eventlog(eventlog_level_error,"versioncheck_create","unable to allocate memory for vc");
  103.     return &dummyvc;
  104. }
  105. if (!(vc->eqn = strdup(vi->eqn)))
  106. {
  107.     eventlog(eventlog_level_error,"versioncheck_create","unable to allocate memory for eqn");
  108.     free(vc);
  109.     return &dummyvc;
  110. }
  111. if (!(vc->mpqfile = strdup(vi->mpqfile)))
  112. {
  113.     eventlog(eventlog_level_error,"versioncheck_create","unable to allocate memory for mpqfile");
  114.     free((void *)vc->eqn); /* avoid warning */
  115.     free(vc);
  116.     return &dummyvc;
  117. }
  118. vc->versiontag = strdup(clienttag);
  120. return vc;
  121.     }
  122.     
  123.     /*
  124.      * No entries in the file that match, return the dummy because we have to send
  125.      * some equation and auth mpq to the client.  The client is not going to pass the
  126.      * validation later unless skip_versioncheck or allow_unknown_version is enabled.
  127.      */
  128.     return &dummyvc;
  129. }
  132. extern int versioncheck_destroy(t_versioncheck * vc)
  133. {
  134.     if (!vc)
  135.     {
  136. eventlog(eventlog_level_error,"versioncheck_destroy","got NULL vc");
  137. return -1;
  138.     }
  139.     
  140.     if (vc==&dummyvc)
  141. return 0;
  142.     
  143.     free((void *)vc->versiontag);
  144.     free((void *)vc->mpqfile);
  145.     free((void *)vc->eqn);
  146.     free(vc);
  147.     
  148.     return 0;
  149. }
  151. extern int versioncheck_set_versiontag(t_versioncheck * vc, char const * versiontag)
  152. {
  153.     if (!vc) {
  154. eventlog(eventlog_level_error,"versioncheck_set_versiontag","got NULL vc");
  155. return -1;
  156.     }
  157.     if (!versiontag) {
  158. eventlog(eventlog_level_error,"versioncheck_set_versiontag","got NULL versiontag");
  159. return -1;
  160.     }
  161.     
  162.     if (vc->versiontag!=NULL) free((void *)vc->versiontag);
  163.     vc->versiontag = strdup(versiontag);
  164.     return 0;
  165. }
  168. extern char const * versioncheck_get_versiontag(t_versioncheck const * vc)
  169. {
  170.     if (!vc) {
  171. eventlog(eventlog_level_error,"versioncheck_get_versiontag","got NULL vc");
  172. return NULL;
  173.     }
  174.     
  175.     return vc->versiontag;
  176. }
  179. extern char const * versioncheck_get_mpqfile(t_versioncheck const * vc)
  180. {
  181.     if (!vc)
  182.     {
  183. eventlog(eventlog_level_error,"versioncheck_get_mpqfile","got NULL vc");
  184. return NULL;
  185.     }
  186.     
  187.     return vc->mpqfile;
  188. }
  191. extern char const * versioncheck_get_eqn(t_versioncheck const * vc)
  192. {
  193.     if (!vc)
  194.     {
  195. eventlog(eventlog_level_error,"versioncheck_get_mpqfile","got NULL vc");
  196. return NULL;
  197.     }
  198.     
  199.     return vc->eqn;
  200. }
  202. t_parsed_exeinfo * parse_exeinfo(char const * exeinfo)
  203. {
  204.   t_parsed_exeinfo * parsed_exeinfo;
  206.     if (!exeinfo) {
  207. return NULL;
  208.     }
  210.     if (!(parsed_exeinfo = malloc(sizeof(t_parsed_exeinfo))))
  211.     {
  212.       eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for parsed exeinfo");
  213.       return NULL;
  214.     }
  216.     if (!(parsed_exeinfo->exe = strdup(exeinfo)))
  217.     {
  218.       free((void *)parsed_exeinfo);
  219.       eventlog(eventlog_level_error,__FUNCTION__,"could not duplicate exeinfo");
  220.       return NULL;
  221.     }
  222.     parsed_exeinfo->time = 0;
  223.     parsed_exeinfo->size = 0;
  224.     
  225.     if (strcmp(prefs_get_version_exeinfo_match(),"parse")==0) 
  226.     {
  227. #ifdef HAVE_MKTIME
  228. struct tm t1;
  229. char *exe;
  230. char mask[MAX_EXEINFO_STR+1];
  231. char * marker;
  232. int size;
  233.         char time_invalid = 0;
  235. if ((exeinfo[0]=='') ||    //happens when using war3-noCD and having deleted war3.org
  236.     (strcmp(exeinfo,"badexe")==0)) //happens when AUTHREQ had no owner/exeinfo entry
  237. {
  238.           free((void *)parsed_exeinfo->exe);
  239.           free((void *)parsed_exeinfo);
  240.           eventlog(eventlog_level_error,__FUNCTION__,"found empty exeinfo");
  241.           return NULL;
  242. }
  244.         memset(&t1,0,sizeof(t1));
  245.         t1.tm_isdst = -1;
  247.         exeinfo    = strreverse((char *)exeinfo);
  248.         if (!(marker     = strchr(exeinfo,' ')))
  249.         {
  250.   free((void *)parsed_exeinfo->exe);
  251.   free((void *)parsed_exeinfo);
  252.   return NULL;
  253.         }
  254. for (; marker[0]==' ';marker++); 
  256.         if (!(marker     = strchr(marker,' ')))
  257.         {
  258.   free((void *)parsed_exeinfo->exe);
  259.   free((void *)parsed_exeinfo);
  260.   return NULL;
  261. } 
  262. for (; marker[0]==' ';marker++);
  264.         if (!(marker     = strchr(marker,' ')))
  265.         {
  266.   free((void *)parsed_exeinfo->exe);
  267.   free((void *)parsed_exeinfo);
  268.   return NULL;
  269. }
  270.         for (; marker[0]==' ';marker++);
  271.         marker--;
  272.         marker[0]  = '';
  273.         marker++; 
  274.         
  275.         if (!(exe = strdup(marker)))
  276.         {
  277.           free((void *)parsed_exeinfo->exe);
  278.           free((void *)parsed_exeinfo);
  279.           eventlog(eventlog_level_error,__FUNCTION__,"could not duplicate exe");
  280.           return NULL;
  281.         }
  282.         free((void *)parsed_exeinfo->exe);
  283.         parsed_exeinfo->exe = strreverse((char *)exe);
  285.         exeinfo    = strreverse((char *)exeinfo);
  287. sprintf(mask,"%%02u/%%02u/%%u %%02u:%%02u:%%02u %%u");
  289. if (sscanf(exeinfo,mask,&t1.tm_mon,&t1.tm_mday,&t1.tm_year,&t1.tm_hour,&t1.tm_min,&t1.tm_sec,&size)!=7) {
  290.             if (sscanf(exeinfo,"%*s %*s %u",&size) != 1)
  291.             {
  293.       eventlog(eventlog_level_warn,__FUNCTION__,"parser error while parsing pattern "%s"",exeinfo);
  294.       free((void *)parsed_exeinfo->exe);
  295.       free((void *)parsed_exeinfo);
  296.       return NULL; /* neq */
  297.             }
  298.             time_invalid=1;
  299. }
  301.        /* Now we have a Y2K problem :)  Thanks for using a 2 digit decimal years, Blizzard. */ 
  302.        /* 00-79 -> 2000-2079 
  303. *             * 80-99 -> 1980-1999 
  304. *             * 100+ unchanged */ 
  305.        if (t1.tm_year<80) 
  306.  t1.tm_year = t1.tm_year + 100; 
  308.        if (time_invalid)
  309.          parsed_exeinfo->time = -1;
  310.        else 
  311.          parsed_exeinfo->time = mktime(&t1);
  312.        parsed_exeinfo->size = size;
  314. #else
  315. eventlog(eventlog_level_error,__FUNCTION__,"Your system does not support mktime(). Please select another exeinfo matching method.");
  316. return NULL;
  317. #endif
  318.   }
  320.   return parsed_exeinfo;
  321. }
  323. #define safe_toupper(X) (islower((int)X)?toupper((int)X):(X))
  325. /* This implements some dumb kind of pattern matching. Any '?'
  326.  * signs in the pattern are treated as "don't care" signs. This
  327.  * means that it doesn't matter what's on this place in the match.
  328.  */
  329. //static int versioncheck_compare_exeinfo(char const * pattern, char const * match)
  330. static int versioncheck_compare_exeinfo(t_parsed_exeinfo * pattern, t_parsed_exeinfo * match)
  331. {
  332.     if (!pattern) {
  333. eventlog(eventlog_level_error,"versioncheck_compare_exeinfo","got NULL pattern");
  334. return -1; /* neq/fail */
  335.     }
  336.     if (!match) {
  337. eventlog(eventlog_level_error,"versioncheck_compare_exeinfo","got NULL match");
  338. return -1; /* neq/fail */
  339.     }
  341.     if (strlen(pattern->exe)!=strlen(match->exe))
  342.      return 1; /* neq */
  343.     
  344.     if (strcmp(prefs_get_version_exeinfo_match(),"exact")==0) {
  345. return strcasecmp(pattern->exe,match->exe);
  346.     } else if (strcmp(prefs_get_version_exeinfo_match(),"exactcase")==0) {
  347. return strcmp(pattern->exe,match->exe);
  348.     } else if (strcmp(prefs_get_version_exeinfo_match(),"wildcard")==0) {
  349.      unsigned int i;
  350.     
  351.      for (i=0;i<strlen(pattern->exe);i++)
  352.          if ((pattern->exe[i]!='?')&& /* out "don't care" sign */
  353.           (safe_toupper(pattern->exe[i])!=safe_toupper(match->exe[i])))
  354.           return 1; /* neq */
  355.      return 0; /* ok */
  356.     } else if (strcmp(prefs_get_version_exeinfo_match(),"parse")==0) {
  357.        
  358.        if (strcasecmp(pattern->exe,match->exe)!=0)
  359.             {
  360.             eventlog(eventlog_level_trace,__FUNCTION__,"filename differs");
  361.     return 1; /* neq */
  362.             }
  363. if (pattern->size!=match->size)
  364.             {
  365.             eventlog(eventlog_level_trace,__FUNCTION__,"size differs");
  366.     return 1; /* neq */
  367.             }
  368. if ((pattern->time!=-1) && prefs_get_version_exeinfo_maxdiff() && (abs(pattern->time-match->time)>(signed)prefs_get_version_exeinfo_maxdiff()))
  369.             {
  370.             eventlog(eventlog_level_trace,__FUNCTION__,"time differs by %i",abs(pattern->time-match->time));
  371.     return 1;
  372.             }
  373. return 0; /* ok */
  374.     } else {
  375. eventlog(eventlog_level_error,"versioncheck_compare_exeinfo","unknown version exeinfo match method "%s"",prefs_get_version_exeinfo_match());
  376. return -1; /* neq/fail */
  377.     }
  378. }
  380. void free_parsed_exeinfo(t_parsed_exeinfo * parsed_exeinfo)
  381. {
  382.   if (parsed_exeinfo)
  383.   {
  384.     if (parsed_exeinfo->exe) 
  385.       free((void *)parsed_exeinfo->exe);
  386.     free((void *)parsed_exeinfo);
  387.   }
  388. }
  390. extern int versioncheck_validate(t_versioncheck * vc, char const * archtag, char const * clienttag, char const * exeinfo, unsigned long versionid, unsigned long gameversion, unsigned long checksum)
  391. {
  392.     t_elem const     * curr;
  393.     t_versioninfo    * vi;
  394.     int                badexe,badcs;
  395.     t_parsed_exeinfo * parsed_exeinfo;
  396.     
  397.     if (!vc)
  398.     {
  399. eventlog(eventlog_level_error,"versioncheck_validate","got NULL vc");
  400. return -1;
  401.     }
  402.     
  403.     badexe=badcs = 0;
  404.     parsed_exeinfo = parse_exeinfo(exeinfo);
  405.     LIST_TRAVERSE_CONST(versioninfo_head,curr)
  406.     {
  407.         if (!(vi = elem_get_data(curr))) /* should not happen */
  408.         {
  409.     eventlog(eventlog_level_error,"versioncheck_validate","version list contains NULL item");
  410.     continue;
  411.         }
  413. if (strcmp(vi->eqn,vc->eqn)!=0)
  414.     continue;
  415. if (strcmp(vi->mpqfile,vc->mpqfile)!=0)
  416.     continue;
  417. if (strcmp(vi->archtag,archtag)!=0)
  418.     continue;
  419. if (strcmp(vi->clienttag,clienttag)!=0)
  420.     continue;
  422. if (vi->versionid && vi->versionid != versionid)
  423.     continue;
  425. if (vi->gameversion && vi->gameversion != gameversion)
  426.     continue;
  429. if ((!(parsed_exeinfo)) || (vi->parsed_exeinfo && (versioncheck_compare_exeinfo(vi->parsed_exeinfo,parsed_exeinfo) != 0)))
  430. {
  431.     /*
  432.      * Found an entry matching but the exeinfo doesn't match.
  433.      * We need to rember this because if no other matching versions are found
  434.      * we will return badversion.
  435.      */
  436.     badexe = 1;
  437. }
  438. else
  439.     badexe = 0;
  441. if (vi->checksum && vi->checksum != checksum)
  442. {
  443.     /*
  444.      * Found an entry matching but the checksum doesn't match.
  445.      * We need to rember this because if no other matching versions are found
  446.      * we will return badversion.
  447.      */
  448.     badcs = 1;
  449. }
  450. else
  451.     badcs = 0;
  453. if (vc->versiontag)
  454.     free((void *)vc->versiontag);
  455. vc->versiontag = strdup(vi->versiontag);
  457. if (badexe || badcs)
  458.     continue;
  460. /* Ok, version and checksum matches or exeinfo/checksum are disabled
  461.  * anyway we have found a complete match */
  462. eventlog(eventlog_level_info,"versioncheck_validate","got a matching entry: %s",vc->versiontag);
  463.         free_parsed_exeinfo(parsed_exeinfo);
  464. return 1;
  465.     }
  466.     
  467.     if (badcs) /* A match was found but the checksum was different */
  468.     {
  469. eventlog(eventlog_level_info,"versioncheck_validate","bad checksum, closest match is: %s",vc->versiontag);
  470.         free_parsed_exeinfo(parsed_exeinfo);
  471. return -1;
  472.     }
  473.     if (badexe) /* A match was found but the exeinfo string was different */
  474.     {
  475. eventlog(eventlog_level_info,"versioncheck_validate","bad exeinfo, closest match is: %s",vc->versiontag);
  476.         free_parsed_exeinfo(parsed_exeinfo);
  477. return -1;
  478.     }
  479.     
  480.     /* No match in list */
  481.     eventlog(eventlog_level_info,"versioncheck_validate","no match in list, setting to: %s",vc->versiontag);
  482.     free_parsed_exeinfo(parsed_exeinfo);
  483.     return 0;
  484. }
  486. extern int versioncheck_load(char const * filename)
  487. {
  488.     FILE *     fp;
  489.     unsigned int    line;
  490.     unsigned int    pos;
  491.     char *     buff;
  492.     char *     temp;
  493.     char const *    eqn;
  494.     char const *    mpqfile;
  495.     char const *    archtag;
  496.     char const *    clienttag;
  497.     char const *    exeinfo;
  498.     char const *    versionid;
  499.     char const *    gameversion;
  500.     char const *    checksum;
  501.     char const *    versiontag;
  502.     t_versioninfo * vi;
  503.     
  504.     if (!filename)
  505.     {
  506. eventlog(eventlog_level_error,"versioncheck_load","got NULL filename");
  507. return -1;
  508.     }
  509.     
  510.     if (!(versioninfo_head = list_create()))
  511.     {
  512. eventlog(eventlog_level_error,"versioncheck_load","could create list");
  513. return -1;
  514.     }
  515.     if (!(fp = fopen(filename,"r")))
  516.     {
  517. eventlog(eventlog_level_error,"versioncheck_load","could not open file "%s" for reading (fopen: %s)",filename,strerror(errno));
  518. list_destroy(versioninfo_head);
  519. versioninfo_head = NULL;
  520. return -1;
  521.     }
  523.     line = 1;
  524.     for (; (buff = file_get_line(fp)); line++)
  525.     {
  526. for (pos=0; buff[pos]=='t' || buff[pos]==' '; pos++);
  527. if (buff[pos]=='' || buff[pos]=='#')
  528. {
  529.     free(buff);
  530.     continue;
  531. }
  532. if ((temp = strrchr(buff,'#')))
  533. {
  534.     unsigned int len;
  535.     unsigned int endpos;
  536.     
  537.     *temp = '';
  538.     len = strlen(buff)+1;
  539.     for (endpos=len-1;  buff[endpos]=='t' || buff[endpos]==' '; endpos--);
  540.     buff[endpos+1] = '';
  541. }
  543. if (!(eqn = next_token(buff,&pos)))
  544. {
  545.     eventlog(eventlog_level_error,"versioncheck_load","missing eqn near line %u of file "%s"",line,filename);
  546.     free(buff);
  547.     continue;
  548. }
  549. line++;
  550. if (!(mpqfile = next_token(buff,&pos)))
  551. {
  552.     eventlog(eventlog_level_error,"versioncheck_load","missing mpqfile near line %u of file "%s"",line,filename);
  553.     free(buff);
  554.     continue;
  555. }
  556. line++;
  557. if (!(archtag = next_token(buff,&pos)))
  558. {
  559.     eventlog(eventlog_level_error,"versioncheck_load","missing archtag near line %u of file "%s"",line,filename);
  560.     free(buff);
  561.     continue;
  562. }
  563. line++;
  564. if (!(clienttag = next_token(buff,&pos)))
  565. {
  566.     eventlog(eventlog_level_error,"versioncheck_load","missing clienttag near line %u of file "%s"",line,filename);
  567.     free(buff);
  568.     continue;
  569. }
  570. line++;
  571. if (!(exeinfo = next_token(buff,&pos)))
  572. {
  573.     eventlog(eventlog_level_error,"versioncheck_load","missing exeinfo near line %u of file "%s"",line,filename);
  574.     free(buff);
  575.     continue;
  576. }
  577. line++;
  578. if (!(versionid = next_token(buff,&pos)))
  579. {
  580.     eventlog(eventlog_level_error,"versioncheck_load","missing versionid near line %u of file "%s"",line,filename);
  581.     free(buff);
  582.     continue;
  583. }
  584. line++;
  585. if (!(gameversion = next_token(buff,&pos)))
  586. {
  587.     eventlog(eventlog_level_error,"versioncheck_load","missing gameversion near line %u of file "%s"",line,filename);
  588.     free(buff);
  589.     continue;
  590. }
  591. line++;
  592. if (!(checksum = next_token(buff,&pos)))
  593. {
  594.     eventlog(eventlog_level_error,"versioncheck_load","missing checksum near line %u of file "%s"",line,filename);
  595.     free(buff);
  596.     continue;
  597. }
  598. line++;
  599. if (!(versiontag = next_token(buff,&pos)))
  600. {
  601.     versiontag = NULL;
  602. }
  604. if (!(vi = malloc(sizeof(t_versioninfo))))
  605. {
  606.     eventlog(eventlog_level_error,"versioncheck_load","could not allocate memory for vi");
  607.     free(buff);
  608.     continue;
  609. }
  610. if (!(vi->eqn = strdup(eqn)))
  611. {
  612.     eventlog(eventlog_level_error,"versioncheck_load","could not allocate memory for eqn");
  613.     free(vi);
  614.     free(buff);
  615.     continue;
  616. }
  617. if (!(vi->mpqfile = strdup(mpqfile)))
  618. {
  619.     eventlog(eventlog_level_error,"versioncheck_load","could not allocate memory for mpqfile");
  620.     free((void *)vi->eqn); /* avoid warning */
  621.     free(vi);
  622.     free(buff);
  623.     continue;
  624. }
  625. if (strlen(archtag)!=4)
  626. {
  627.     eventlog(eventlog_level_error,"versioncheck_load","invalid arch tag on line %u of file "%s"",line,filename);
  628.     free((void *)vi->mpqfile); /* avoid warning */
  629.     free((void *)vi->eqn); /* avoid warning */
  630.     free(vi);
  631.     free(buff);
  632.     continue;
  633. }
  634. if (!(vi->archtag = strdup(archtag)))
  635. {
  636.     eventlog(eventlog_level_error,"versioncheck_load","could not allocate memory for archtag");
  637.     free((void *)vi->mpqfile); /* avoid warning */
  638.     free((void *)vi->eqn); /* avoid warning */
  639.     free(vi);
  640.     free(buff);
  641.     continue;
  642. }
  643. if (strlen(clienttag)!=4)
  644. {
  645.     eventlog(eventlog_level_error,"versioncheck_load","invalid client tag on line %u of file "%s"",line,filename);
  646.     free((void *)vi->archtag); /* avoid warning */
  647.     free((void *)vi->mpqfile); /* avoid warning */
  648.     free((void *)vi->eqn); /* avoid warning */
  649.     free(vi);
  650.     free(buff);
  651.     continue;
  652. }
  653. if (!(vi->clienttag = strdup(clienttag)))
  654. {
  655.     eventlog(eventlog_level_error,"versioncheck_load","could not allocate memory for clienttag");
  656.     free((void *)vi->archtag); /* avoid warning */
  657.     free((void *)vi->mpqfile); /* avoid warning */
  658.     free((void *)vi->eqn); /* avoid warning */
  659.     free(vi);
  660.     free(buff);
  661.     continue;
  662. }
  663. if (strcmp(exeinfo, "NULL") == 0)
  664.     vi->parsed_exeinfo = NULL;
  665. else
  666. {
  667.     if (!(vi->parsed_exeinfo = parse_exeinfo(exeinfo)))
  668.     {
  669. eventlog(eventlog_level_error,"versioncheck_load","encountered an error while parsing exeinfo");
  670. free((void *)vi->clienttag); /* avoid warning */
  671. free((void *)vi->archtag); /* avoid warning */
  672. free((void *)vi->mpqfile); /* avoid warning */
  673. free((void *)vi->eqn); /* avoid warning */
  674. free(vi);
  675. free(buff);
  676. continue;
  677.     }
  678. }
  680. vi->versionid = strtoul(versionid,NULL,0);
  681. if (verstr_to_vernum(gameversion,&vi->gameversion)<0)
  682. {
  683.     eventlog(eventlog_level_error,"versioncheck_load","malformed version on line %u of file "%s"",line,filename);
  684.     free((void *)vi->parsed_exeinfo); /* avoid warning */
  685.     free((void *)vi->clienttag); /* avoid warning */
  686.     free((void *)vi->archtag); /* avoid warning */
  687.     free((void *)vi->mpqfile); /* avoid warning */
  688.     free((void *)vi->eqn); /* avoid warning */
  689.     free(vi);
  690.     free(buff);
  691.     continue;
  692.         }
  694. vi->checksum = strtoul(checksum,NULL,0);
  695. if (versiontag)
  696. {
  697.     if (!(vi->versiontag = strdup(versiontag)))
  698.     {
  699. eventlog(eventlog_level_error,"versioncheck_load","could not allocate memory for versiontag");
  700. free((void *)vi->parsed_exeinfo); /* avoid warning */
  701. free((void *)vi->clienttag); /* avoid warning */
  702. free((void *)vi->archtag); /* avoid warning */
  703. free((void *)vi->mpqfile); /* avoid warning */
  704. free((void *)vi->eqn); /* avoid warning */
  705. free(vi);
  706. free(buff);
  707. continue;
  708.     }
  709. }
  710. else
  711.     vi->versiontag = NULL;
  713. free(buff);
  715. if (list_append_data(versioninfo_head,vi)<0)
  716. {
  717.     eventlog(eventlog_level_error,"versioncheck_load","could not append item");
  718.     if (vi->versiontag)
  719.       free((void *)vi->versiontag); /* avoid warning */
  720.     free((void *)vi->parsed_exeinfo); /* avoid warning */
  721.     free((void *)vi->clienttag); /* avoid warning */
  722.     free((void *)vi->archtag); /* avoid warning */
  723.     free((void *)vi->mpqfile); /* avoid warning */
  724.     free((void *)vi->eqn); /* avoid warning */
  725.     free(vi);
  726.     continue;
  727. }
  728.     }
  729.     
  730.     if (fclose(fp)<0)
  731. eventlog(eventlog_level_error,"versioncheck_load","could not close versioncheck file "%s" after reading (fclose: %s)",filename,strerror(errno));
  732.     
  733.     return 0;
  734. }
  737. extern int versioncheck_unload(void)
  738. {
  739.     t_elem *     curr;
  740.     t_versioninfo * vi;
  741.     
  742.     if (versioninfo_head)
  743.     {
  744. LIST_TRAVERSE(versioninfo_head,curr)
  745. {
  746.     if (!(vi = elem_get_data(curr))) /* should not happen */
  747.     {
  748. eventlog(eventlog_level_error,"versioncheck_unload","version list contains NULL item");
  749. continue;
  750.     }
  751.     
  752.     if (list_remove_elem(versioninfo_head,curr)<0)
  753. eventlog(eventlog_level_error,"versioncheck_unload","could not remove item from list");
  755.     if (vi->parsed_exeinfo)
  756.             {
  757.                 if (vi->parsed_exeinfo->exe)
  758.                     free((void *)vi->parsed_exeinfo->exe);
  759. free((void *)vi->parsed_exeinfo); /* avoid warning */
  760.             }
  761.     free((void *)vi->clienttag); /* avoid warning */
  762.     free((void *)vi->archtag); /* avoid warning */
  763.     free((void *)vi->mpqfile); /* avoid warning */
  764.     free((void *)vi->eqn); /* avoid warning */
  765.     if (vi->versiontag)
  766. free((void *)vi->versiontag); /* avoid warning */
  767.     free(vi);
  768. }
  770. if (list_destroy(versioninfo_head)<0)
  771.     return -1;
  772. versioninfo_head = NULL;
  773.     }
  774.     
  775.     return 0;
  776. }