PageRenderTime 122ms CodeModel.GetById 20ms RepoModel.GetById 1ms app.codeStats 1ms

/formprocessor.php

https://bitbucket.org/dmptool/dmp2brochure
PHP | 13406 lines | 9591 code | 698 blank | 3117 comment | 673 complexity | 617c934ab1b7e9aacfa1aee055a0dfbb MD5 | raw file
    

  1. <?php

    2. 

  2. $FM_VERS = "8.36";      // script version

    3. 

  3. 

    4. 

  4. /* ex:set ts=4 sw=4 et:

    5. 

  5.  * FormMail PHP script from Tectite.com.  This script requires PHP 4 or later.

    6. 

  6.  * Copyright (c) 2001-2012 Root Software and Open Concepts (Vic) Pty Ltd

    7. 

  7.  * (ABN 12 130 429 248), Melbourne, Australia.

    8. 

  8.  * This script is free for all use as described in the "Copying and Use" and

    9. 

  9.  * "Warranty and Disclaimer" sections below.

    10. 

  10.  *

    11. 

  11.  * Visit us at http://www.tectite.com/ for updates and more information.

    12. 

  12.  *

    13. 

  13.  *** If you use Tectite FormMail, please support its development and other

    14. 

  14.  *** freeware products by putting the following link on your website:

    15. 

  15.  ***  Visit www.tectite.com for free <a href="http://www.tectite.com/">FormMail</a>.

    16. 

  16.  *

    17. 

  17.  * Author: Russell Robinson, 2nd October 2001

    18. 

  18.  *

    19. 

  19.  * Read This First

    20. 

  20.  * ~~~~~~~~~~~~~~~

    21. 

  21.  *  This script is very well documented and quite large!  It looks daunting,

    22. 

  22.  *  but really isn't.

    23. 

  23.  *  If you have experience with PHP or other scripting languages,

    24. 

  24.  *  here's what you *need* to read:

    25. 

  25.  *      - Configuration (TARGET_EMAIL & DEF_ALERT)

    26. 

  26.  *      - Creating Forms

    27. 

  27.  *  That's it!  (Alternatively, just read the Quick Start and/or

    28. 

  28.  *  Quicker Start section below).

    29. 

  29.  *  Full configuration documentation is here:

    30. 

  30.  *      http://www.tectite.com/fmdoc/index.php

    31. 

  31.  *

    32. 

  32.  *  NOTE: do not read or modify this script or any PHP script

    33. 

  33.  *  with DreamWeaver or FrontPage!

    34. 

  34.  *  Many versions of those programs silently corrupt PHP scripts.

    35. 

  35.  *

    36. 

  36.  * Purpose:

    37. 

  37.  * ~~~~~~~~

    38. 

  38.  *  To accept information from an HTML form via HTTP and mail it to recipients.

    39. 

  39.  *

    40. 

  40.  * What does this PHP script do?

    41. 

  41.  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    42. 

  42.  *  On your web site, you may have one or more HTML forms that accept

    43. 

  43.  *  information from people visiting your website.  Your aim is for your

    44. 

  44.  *  website to email that information to you and/or add it to a database.

    45. 

  45.  *  FormMail performs those functions.

    46. 

  46.  *

    47. 

  47.  * Quick Start

    48. 

  48.  * ~~~~~~~~~~~

    49. 

  49.  *  1. Edit this file and set TARGET_EMAIL for your requirements (near

    50. 

  50.  *      line 256 in this file - replace "yourhost\.com" with your mail server's

    51. 

  51.  *      name).  We also strongly recommend you set DEF_ALERT (the next

    52. 

  52.  *      configuration below TARGET_EMAIL).

    53. 

  53.  *  2. Install this file as formmail.php (or other name ending in .php)

    54. 

  54.  *     on your web server.

    55. 

  55.  *     Test alerts by using your browser to open a URL to the script:

    56. 

  56.  *          http://www.yourhost.com/formmail.php?testalert=1

    57. 

  57.  *     Alerts are the only way FormMail can tell you the details of

    58. 

  58.  *     errors or faults.

    59. 

  59.  *  3. Create an HTML form and:

    60. 

  60.  *      - specify a hidden field called "recipients" with the email address

    61. 

  61.  *        of the person to receive the form's results.

    62. 

  62.  *      - in the your form tag set the action attribute to

    63. 

  63.  *        the formmail.php you uploaded to your web server

    64. 

  64.  *

    65. 

  65.  *  Once you have FormMail working, you may be interested in some advanced

    66. 

  66.  *  usage and features.  We have HOW-TO guides at www.tectite.com which

    67. 

  67.  *  describe many of the advanced processing you can do with FormMail.

    68. 

  68.  *      http://www.tectite.com/fmhowto/guides.php

    69. 

  69.  *

    70. 

  70.  * Quicker Start

    71. 

  71.  * ~~~~~~~~~~~~~

    72. 

  72.  *  Use the FormMail Configuration Wizard here:

    73. 

  73.  *      http://www.tectite.com/wizards/fmconf.php

    74. 

  74.  *  By answering a few questions you'll get a configured FormMail and

    75. 

  75.  *  a sample HTML form ready to upload and use on your server.

    76. 

  76.  *

    77. 

  77.  * Features

    78. 

  78.  * ~~~~~~~~

    79. 

  79.  *  For a list of features go to: http://www.tectite.com/formmailpage.php

    80. 

  80.  *

    81. 

  81.  * Security

    82. 

  82.  * ~~~~~~~~

    83. 

  83.  *  Security is the primary concern in accepting data from your website

    84. 

  84.  *  visitors.

    85. 

  85.  *  Tectite FormMail has several security features designed into it.  Note,

    86. 

  86.  *  however, it requires configuration for your particular web site.

    87. 

  87.  *

    88. 

  88.  * Configuration

    89. 

  89.  * ~~~~~~~~~~~~~

    90. 

  90.  *  To configure this script, go to the section titled "CONFIGURATION"

    91. 

  91.  *  (after reading the legal stuff below).

    92. 

  92.  *

    93. 

  93.  *  There is only one mandatory setting: TARGET_EMAIL

    94. 

  94.  *  and one strongly recommended setting: DEF_ALERT

    95. 

  95.  *

    96. 

  96.  *  Full configuration information is available here:

    97. 

  97.  *      http://www.tectite.com/fmdoc/index.php

    98. 

  98.  *

    99. 

  99.  * Creating Forms

    100. 

  100.  * ~~~~~~~~~~~~~~

    101. 

  101.  *  Go to this URL to learn how to write HTML forms for use with

    102. 

  102.  *  Tectite FormMail: http://www.tectite.com/fmdoc/creating_forms.php

    103. 

  103.  *

    104. 

  104.  * Copying and Use (Software License)

    105. 

  105.  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    106. 

  106.  *  Tectite FormMail is provided free of charge and may be freely distributed

    107. 

  107.  *  and used provided that you:

    108. 

  108.  *      1. keep this header, including copyright and comments,

    109. 

  109.  *         in place and unmodified; and,

    110. 

  110.  *      2. do not charge a fee for distributing it, without an agreement

    111. 

  111.  *         in writing with Root Software allowing you to do so; and,

    112. 

  112.  *      3. if you modify FormMail before distributing it, you clearly

    113. 

  113.  *         identify:

    114. 

  114.  *              a) who you are

    115. 

  115.  *              b) how to contact you

    116. 

  116.  *              c) what changes you have made

    117. 

  117.  *              d) why you have made those changes.

    118. 

  118.  *

    119. 

  119.  *  By using any of our products, including this script, you are

    120. 

  120.  *  agreeing to our standard Terms and Conditions, available here:

    121. 

  121.  *      http://www.tectite.com/TermsAndConditions.pdf

    122. 

  122.  *

    123. 

  123.  *  This is free software and the Software License shown above

    124. 

  124.  *  is to be read in conjunction with our standard Terms and Conditions.

    125. 

  125.  *

    126. 

  126.  * Warranty and Disclaimer

    127. 

  127.  * ~~~~~~~~~~~~~~~~~~~~~~~

    128. 

  128.  *  Tectite FormMail is provided free-of-charge and with ABSOLUTELY NO WARRANTY.

    129. 

  129.  *  It has not been verified for use in critical applications, including,

    130. 

  130.  *  but not limited to, medicine, defense, aircraft, space exploration,

    131. 

  131.  *  or any other potentially dangerous activity.

    132. 

  132.  *

    133. 

  133.  *  By using Tectite FormMail you agree to indemnify Root Software and

    134. 

  134.  *  Open Concepts (Vic) Pty Ltd, their agents, employees, directors and

    135. 

  135.  *  associated companies and businesses from any liability whatsoever.

    136. 

  136.  *

    137. 

  137.  * We still care

    138. 

  138.  * ~~~~~~~~~~~~~

    139. 

  139.  *  If you find a bug or fault in FormMail, please report it to us.

    140. 

  140.  *  We will respond to your report and make endeavours to rectify any

    141. 

  141.  *  faults you've detected as soon as possible.

    142. 

  142.  *

    143. 

  143.  *  To contact us please register on our forums at:

    144. 

  144.  *      http://www.tectite.com/vbforums/

    145. 

  145.  *  or view our contact information:

    146. 

  146.  *      http://www.tectite.com/contacts.php

    147. 

  147.  *

    148. 

  148.  * Version History

    149. 

  149.  * ~~~~~~~~~~~~~~~

    150. 

  150.  *  Near the top of this file, you'll find its version. The version

    151. 

  151.  *  line looks like this:

    152. 

  152.  *       $FM_VERS = "N.MM";     /* script version ...

    153. 

  153.  *

    154. 

  154.  *  The version history used to be located within this file.  However,

    155. 

  155.  *  starting with Version 8.00 we've moved it...

    156. 

  156.  *

    157. 

  157.  *  You can read the complete version history of FormMail on our

    158. 

  158.  *  main website here:

    159. 

  159.  *   http://www.tectite.com/fmdoc/version_history.php

    160. 

  160.  */

    161. 

  161. 

    162. 

  162. FMDebug('Submission to: '.(isset($_SERVER['PHP_SELF']) ? $_SERVER['PHP_SELF'] : '').' from: '.(isset($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : ''));

    163. 

  163. 

    164. 

  164. if (isset($_SERVER['REQUEST_METHOD']) && strtoupper($_SERVER['REQUEST_METHOD']) === 'OPTIONS')

    165. 

  165. {

    166. 

  166.     FMDebug('CORS OPTIONS request');

    167. 

  167.     CORS_Response();

    168. 

  168.     exit;

    169. 

  169. }

    170. 

  170. 

    171. 

  171.     //

    172. 

  172.     // Capture the current date and time, for various purposes.

    173. 

  173.     //

    174. 

  174. $lNow = time();

    175. 

  175. 

    176. 

  176. ini_set('track_errors',1);          // enable $php_errormsg

    177. 

  177. 

    178. 

  178. $aAlertInfo = array();

    179. 

  179. $aPHPVERSION = array();

    180. 

  180. 

    181. 

  181. $sLangID = "";                      // the language ID

    182. 

  182. $aMessages = array();               // all FormMail messages in the appropriate

    183. 

  183.                                     // language

    184. 

  184. 

    185. 

  185. $bUseOldVars = IsOldVersion($aPHPVERSION);

    186. 

  186. 

    187. 

  187. if (!IsPHPAtLeast("5.3.0"))

    188. 

  188.         //

    189. 

  189.         // disable this silly setting (usually not enabled)

    190. 

  190.         // it's also deprecated from PHP version 5.3.0

    191. 

  191.         //

    192. 

  192.     set_magic_quotes_runtime(0);       

    193. 

  193. 

    194. 

  194.     //

    195. 

  195.     // seed the random number generate if not version 4.2.0 or later

    196. 

  196.     //

    197. 

  197. if (!IsPHPAtLeast("4.2.0"))

    198. 

  198.     mt_srand(time());

    199. 

  199. 

    200. 

  200.     //

    201. 

  201.     // we set references to the appropriate arrays to handle PHP version differences

    202. 

  202.     // Session vars are selected after we start the session.

    203. 

  203.     //

    204. 

  204. if ($bUseOldVars)

    205. 

  205. {

    206. 

  206.     $aServerVars = &$HTTP_SERVER_VARS;

    207. 

  207.     $aGetVars = &$HTTP_GET_VARS;

    208. 

  208. 

    209. 

  209.     $aFormVars = &$HTTP_POST_VARS;

    210. 

  210.     $aFileVars = &$HTTP_POST_FILES;

    211. 

  211.     $aEnvVars = &$HTTP_ENV_VARS;

    212. 

  212. }

    213. 

  213. else

    214. 

  214. {

    215. 

  215.     $aServerVars = &$_SERVER;

    216. 

  216.     $aGetVars = &$_GET;

    217. 

  217.     $aFormVars = &$_POST;

    218. 

  218.     $aFileVars = &$_FILES;

    219. 

  219.     $aEnvVars = &$_ENV;

    220. 

  220. }

    221. 

  221. $bIsGetMethod = false;

    222. 

  222. $bHasGetData = false;

    223. 

  223. 

    224. 

  224. if (!isset($REAL_DOCUMENT_ROOT))

    225. 

  225.     SetRealDocumentRoot();

    226. 

  226. 

    227. 

  227. if (isset($aServerVars['SERVER_PORT']))

    228. 

  228.     $SCHEME = ($aServerVars['SERVER_PORT'] == 80) ? "http://" : "https://";

    229. 

  229. else

    230. 

  230.     $SCHEME = "";

    231. 

  231. if (isset($aServerVars['SERVER_NAME']) && $aServerVars['SERVER_NAME'] !== "")

    232. 

  232.     $SERVER = $aServerVars['SERVER_NAME'];

    233. 

  233. elseif (isset($aServerVars['SERVER_ADDR']) && $aServerVars['SERVER_ADDR'] !== "")

    234. 

  234.     $SERVER = $aServerVars['SERVER_ADDR'];

    235. 

  235. else

    236. 

  236.     $SERVER = "";

    237. 

  237. 

    238. 

  238.     /*

    239. 

  239.      * Load an optional include file before the configuration.

    240. 

  240.      * You can use this to set variables that can be used in the

    241. 

  241.      * configuration section.

    242. 

  242.      */

    243. 

  243. @include("formmail-preconfig.inc.php");

    244. 

  244. 

    245. 

  245. /*****************************************************************************/

    246. 

  246. /* CONFIGURATION (do not alter this line in any way!!!)                      */

    247. 

  247. /*****************************************************************************

    248. 

  248.  * This is the *only* place where you need to modify things to use formmail.php

    249. 

  249.  * on your particular system.  This section finishes at "END OF CONFIGURATION".

    250. 

  250.  * Help for all settings can be found on our website:

    251. 

  251.  *  http://www.tectite.com/fmdoc/index.php

    252. 

  252.  *

    253. 

  253.  * Also, above each setting is a direct URL to the help information for the

    254. 

  254.  * setting.

    255. 

  255.  *****************************************************************************/

    256. 

  256. 

    257. 

  257.             /* Help: http://www.tectite.com/fmdoc/email_name.php */

    258. 

  258. define("EMAIL_NAME","^[-a-z0-9.]+");    // the '^' is an important security feature!

    259. 

  259. 

    260. 

  260.             /* Help: http://www.tectite.com/fmdoc/target_email.php */

    261. 

  261. $TARGET_EMAIL = array("^uc3@ucop\.edu$");

    262. 

  262. // $TARGET_EMAIL = array("^joel\.hagedorn@ucop\.edu$");

    263. 

  263. 

    264. 

  264.             /* Help: http://www.tectite.com/fmdoc/def_alert.php */

    265. 

  265. 

    266. 

  266. define("DEF_ALERT","joel.hagedorn@ucop.edu");

    267. 

  267. 

    268. 

  268.             /* Help: http://www.tectite.com/fmdoc/site_domain.php */

    269. 

  269. $SITE_DOMAIN = "";           // your website domain name

    270. 

  270. 

    271. 

  271.             /* Help: http://www.tectite.com/fmdoc/set_real_document_root.php */

    272. 

  272. $SET_REAL_DOCUMENT_ROOT = "";       // overrides the value set by SetRealDocumentRoot function

    273. 

  273. 

    274. 

  274.     //

    275. 

  275.     // override $REAL_DOCUMENT_ROOT from the $SET_REAL_DOCUMENT_ROOT value (if any)

    276. 

  276.     // Do not alter the following code (next 3 lines)!

    277. 

  277.     //

    278. 

  278. if (isset($SET_REAL_DOCUMENT_ROOT) && $SET_REAL_DOCUMENT_ROOT !== "")

    279. 

  279.     $REAL_DOCUMENT_ROOT = $SET_REAL_DOCUMENT_ROOT;

    280. 

  280. 

    281. 

  281.             /* Help: http://www.tectite.com/fmdoc/config_check.php */

    282. 

  282. $CONFIG_CHECK = array("TARGET_EMAIL");

    283. 

  283. 

    284. 

  284.             /* Help: http://www.tectite.com/fmdoc/at_mangle.php */

    285. 

  285. define("AT_MANGLE","ATT");

    286. 

  286. 

    287. 

  287.             /* Help: http://www.tectite.com/fmdoc/target_urls.php */

    288. 

  288. $TARGET_URLS = array();         // default; no URLs allowed

    289. 

  289. 

    290. 

  290.             /* Help: http://www.tectite.com/fmdoc/head_crlf.php */

    291. 

  291. define("HEAD_CRLF","\r\n");

    292. 

  292. 

    293. 

  293.             /* Help: http://www.tectite.com/fmdoc/body_lf.php */

    294. 

  294. define("BODY_LF","\r\n");       // the new default: use this for CR+LF

    295. 

  295. //define("BODY_LF","\n");       // the old default: just LF

    296. 

  296. 

    297. 

  297.             /* Help: http://www.tectite.com/fmdoc/from_user.php */

    298. 

  298. $FROM_USER = "";                            // the default - setting not used

    299. 

  299. 

    300. 

  300.             /* Help: http://www.tectite.com/fmdoc/sendmail_f_option.php */

    301. 

  301. define("SENDMAIL_F_OPTION",false);

    302. 

  302. define("SENDMAIL_F_OPTION_LINE",__LINE__-1);    // don't modify this line!

    303. 

  303. 

    304. 

  304.             /* Help: http://www.tectite.com/fmdoc/fixed_sender.php */

    305. 

  305. $FIXED_SENDER = "";

    306. 

  306. 

    307. 

  307.             /* Help: http://www.tectite.com/fmdoc/set_sender_from_email.php */

    308. 

  308. define("SET_SENDER_FROM_EMAIL",false);

    309. 

  309. 

    310. 

  310.             /* Help: http://www.tectite.com/fmdoc/ini_set_from.php */

    311. 

  311. define("INI_SET_FROM",false);

    312. 

  312. 

    313. 

  313. 

    314. 

  314.             /* Help: http://www.tectite.com/fmdoc/logdir.php */

    315. 

  315. $LOGDIR = "";                           // directory for log files; empty string to

    316. 

  316.                                         // disallow log files

    317. 

  317.             /* Help: http://www.tectite.com/fmdoc/autorespondlog.php */

    318. 

  318. $AUTORESPONDLOG = "";           // file name in $LOGDIR for the auto responder

    319. 

  319.                                 // log; empty string for no auto responder log

    320. 

  320. 

    321. 

  321.             /* Help: http://www.tectite.com/fmdoc/csv_file_settings.php */

    322. 

  322. $CSVDIR = "";                       // directory for csv files; empty string to

    323. 

  323.                                     // disallow csv files

    324. 

  324. $CSVSEP = ",";      // comma separator between fields (columns)

    325. 

  325. $CSVINTSEP = ";";   // semicolon is the separator for fields (columns)

    326. 

  326.                     // with multiple values (checkboxes, etc.)

    327. 

  327. $CSVQUOTE = '"';    // all fields in the CSV are quoted with this character;

    328. 

  328.                     // default is double quote.  You can change it to

    329. 

  329.                     // single quote or leave it empty for no quotes.

    330. 

  330. //$CSVQUOTE = "'";  // use this if you want single quotes

    331. 

  331. $CSVOPEN = "";      // set to "b" to force line terminations to be

    332. 

  332.                     // kept as $CSVLINE setting below, regardless of

    333. 

  333.                     // operating system.  Keep as empty string and

    334. 

  334.                     // leave $CSVLINE unchanged, to get text file

    335. 

  335.                     // terminations for your server's operating system.

    336. 

  336.                     // (Line feed on UNIX, carriage-return line feed on Windows).

    337. 

  337. $CSVLINE = "\n";    // line termination for CSV files.  The default is

    338. 

  338.                     // a single line feed, which may be modified for your

    339. 

  339.                     // server's operating system.  If you want to change

    340. 

  340.                     // this value, you *must* set $CSVOPEN = "b".

    341. 

  341. 

    342. 

  342.             /* Help: http://www.tectite.com/fmdoc/templatedir.php */

    343. 

  343. $TEMPLATEDIR = "";                  // directory for template files; empty string

    344. 

  344.                                     // if you don't have any templates

    345. 

  345. 

    346. 

  346.             /* Help: http://www.tectite.com/fmdoc/templateurl.php */

    347. 

  347. $TEMPLATEURL = "";                  // default; no template URL

    348. 

  348. 

    349. 

  349.             /* Help: http://www.tectite.com/fmdoc/multiformdir.php */

    350. 

  350. $MULTIFORMDIR = "";         // directory for multi-form template files; empty string

    351. 

  351.                             // if you're not using multi-forms

    352. 

  352. 

    353. 

  353.             /* Help: http://www.tectite.com/fmdoc/multiformurl.php */

    354. 

  354. $MULTIFORMURL = "";                 // default; no multi-forms templates URL

    355. 

  355. 

    356. 

  356.             /* Help: http://www.tectite.com/fmdoc/text_subs.php */

    357. 

  357. $TEXT_SUBS = array(

    358. 

  358.     array("srch"=>"/\\\\r\\\\n/","repl"=>"\r\n",),

    359. 

  359.     array("srch"=>"/\\\\n/","repl"=>"\n",),

    360. 

  360.     array("srch"=>"/\\\\t/","repl"=>"\t",),

    361. 

  361.     array("srch"=>"/\\[NL\\]/","repl"=>"\n",),

    362. 

  362.     array("srch"=>"/\\[TAB\\]/","repl"=>"\t",),

    363. 

  363.     array("srch"=>"/\\[NBSP\\]/","repl"=>"&nbsp;",),

    364. 

  364.     array("srch"=>"/\\[DQUOT\\]/","repl"=>'"',),

    365. 

  365.     array("srch"=>"/\\[SQUOT\\]/","repl"=>"'",),

    366. 

  366.     array("srch"=>"/\\[COLON\\]/","repl"=>":",),

    367. 

  367.     array("srch"=>"/\\[SLOSH\\]/","repl"=>"\\",),

    368. 

  368.     array("srch"=>"/\\[OPCURL\\]/","repl"=>"{",),

    369. 

  369.     array("srch"=>"/\\[CLCURL\\]/","repl"=>"}",),

    370. 

  370.     array("srch"=>"/(on[a-z]*|href|src)\\s*=\\s*/i","repl"=>""),/* strip html attributes that could be unsafe */

    371. 

  371.     array("srch"=>"/<\\s*(table|tr|td|th|p|ul|ol|li|b|i|u|strong|pre|h[1-6]|em|dl|dd|dt|hr|span|br)(\\b[^>]*?)>/i","repl"=>"<\$1\$2>",),

    372. 

  372.     array("srch"=>"#<\\s*/\\s*(table|tr|td|th|p|ul|ol|li|b|i|u|strong|pre|h[1-6]|em|dl|dd|dt|hr|span|br)\\s*>#i","repl"=>"</\$1>",),

    373. 

  373.     );

    374. 

  374. 

    375. 

  375.             /* Help: http://www.tectite.com/fmdoc/authentication_settings.php */

    376. 

  376. $AUTHENTICATE = "";

    377. 

  377. //$AUTHENTICATE = "Basic cnVzc2VsbHI6dGVzdA==";        // example

    378. 

  378. $AUTH_USER = "";

    379. 

  379. $AUTH_PW = "";

    380. 

  380. 

    381. 

  381.             /* Help: http://www.tectite.com/fmdoc/form_ini_file.php */

    382. 

  382. $FORM_INI_FILE = "";

    383. 

  383. 

    384. 

  384.             /* Help: http://www.tectite.com/fmdoc/moduledir.php */

    385. 

  385. $MODULEDIR = ".";

    386. 

  386. 

    387. 

  387.             /* Help: http://www.tectite.com/fmdoc/fmcompute.php */

    388. 

  388. $FMCOMPUTE = "fmcompute.php";

    389. 

  389. 

    390. 

  390.             /* Help: http://www.tectite.com/fmdoc/fmgeoip.php */

    391. 

  391. $FMGEOIP = "fmgeoip.php";

    392. 

  392. 

    393. 

  393.             /* Help: http://www.tectite.com/fmdoc/advanced_templates.php */

    394. 

  394. define("ADVANCED_TEMPLATES",false);     // set to true for advanced templates

    395. 

  395. 

    396. 

  396.             /* Help: http://www.tectite.com/fmdoc/limited_import.php */

    397. 

  397. define("LIMITED_IMPORT",true);      // set to true if your database cannot

    398. 

  398.                                     // handle escaped quotes or newlines within

    399. 

  399.                                     // imported data.  Microsoft Access is one

    400. 

  400.                                     // example.

    401. 

  401. 

    402. 

  402.             /* Help: http://www.tectite.com/fmdoc/valid_env.php */

    403. 

  403. $VALID_ENV = array('HTTP_REFERER','REMOTE_HOST','REMOTE_ADDR','REMOTE_USER',

    404. 

  404.                 'HTTP_USER_AGENT');

    405. 

  405. 

    406. 

  406.             /* Help: http://www.tectite.com/fmdoc/fileuploads.php */

    407. 

  407. define("FILEUPLOADS",false);        // set to true to allow file attachments

    408. 

  408. 

    409. 

  409.             /* Help: http://www.tectite.com/fmdoc/max_file_upload_size.php */

    410. 

  410. define("MAX_FILE_UPLOAD_SIZE",0);       // default of 0 means that other software

    411. 

  411.                                         // controls the maximum file upload size

    412. 

  412.                                         // (FormMail doesn't test the file size)

    413. 

  413. 

    414. 

  414.             /* Help: http://www.tectite.com/fmdoc/file_repository.php */

    415. 

  415. $FILE_REPOSITORY = "";

    416. 

  416. 

    417. 

  417.             /* Help: http://www.tectite.com/fmdoc/file_mode.php */

    418. 

  418. define("FILE_MODE",0664);     // always precede with 0 to specify octal!

    419. 

  419. 

    420. 

  420.             /* Help: http://www.tectite.com/fmdoc/file_overwrite.php */

    421. 

  421. define("FILE_OVERWRITE",true);

    422. 

  422. 

    423. 

  423.             /* Help: http://www.tectite.com/fmdoc/next_num_file.php */

    424. 

  424. $NEXT_NUM_FILE = "";

    425. 

  425. 

    426. 

  426.             /* Help: http://www.tectite.com/fmdoc/put_data_in_url.php */

    427. 

  427. define("PUT_DATA_IN_URL",true); // set to true to place data in the URL

    428. 

  428.                                 // for bad_url redirects

    429. 

  429. 

    430. 

  430.             /* Help: http://www.tectite.com/fmdoc/allow_get_method.php */

    431. 

  431. $ALLOW_GET_METHOD = false;

    432. 

  432. 

    433. 

  433.             /* Help: http://www.tectite.com/fmdoc/db_see_input.php */

    434. 

  434. define("DB_SEE_INPUT",false);   // set to true to just see the input values

    435. 

  435. 

    436. 

  436.             /* Help: http://www.tectite.com/fmdoc/db_see_ini.php */

    437. 

  437. define("DB_SEE_INI",false);     // set to true to just see the ini file

    438. 

  438. 

    439. 

  439.             /* Help: http://www.tectite.com/fmdoc/maxstring.php */

    440. 

  440. define("MAXSTRING",1024);       // maximum string length for a value

    441. 

  441. 

    442. 

  442.             /* Help: http://www.tectite.com/fmdoc/require_captcha.php */

    443. 

  443. $REQUIRE_CAPTCHA = "";          // set to a message string if your forms

    444. 

  444.                                 // must provide a CAPTCHA string

    445. 

  445. 

    446. 

  446.             /* Help: http://www.tectite.com/fmdoc/recaptcha_private_key.php */

    447. 

  447. $RECAPTCHA_PRIVATE_KEY = "";

    448. 

  448. 

    449. 

  449.             /* Help: http://www.tectite.com/fmdoc/bshowmesgnumbers.php */

    450. 

  450. $bShowMesgNumbers = false;

    451. 

  451. 

    452. 

  452.             /* Help: http://www.tectite.com/fmdoc/filters.php */

    453. 

  453.             /* Note for Tectite personnel: the upgrade Wizard will merge new values

    454. 

  454.              * but be careful of $var usage and quoting in new entries.

    455. 

  455.              */

    456. 

  456. $FILTERS = array("encode"=>"$REAL_DOCUMENT_ROOT/cgi-bin/fmencoder -kpubkey.txt",

    457. 

  457.                 "null"=>"null",

    458. 

  458.                 "csv"=>"csv");

    459. 

  459. 

    460. 

  460.             /* Help: http://www.tectite.com/fmdoc/socket_filters.php */

    461. 

  461. $SOCKET_FILTERS = array(

    462. 

  462.                  "httpencode"=>array("site"=>"YourSiteHere",

    463. 

  463.                     "port"=>80,

    464. 

  464.                     "path"=>"/cgi-bin/fmencoder",

    465. 

  465.                     "params"=>array(array("name"=>"key",

    466. 

  466.                             "file"=>"$REAL_DOCUMENT_ROOT/cgi-bin/pubkey.txt"))),

    467. 

  467.                  "sslencode"=>array("site"=>"ssl://YourSecureSiteHere",

    468. 

  468.                     "port"=>443,

    469. 

  469.                     "path"=>"/cgi-bin/fmencoder",

    470. 

  470.                     "params"=>array(array("name"=>"key",

    471. 

  471.                             "file"=>"$REAL_DOCUMENT_ROOT/cgi-bin/pubkey.txt"))),

    472. 

  472.                 );

    473. 

  473. 

    474. 

  474.             /* Help: http://www.tectite.com/fmdoc/filter_attribs.php */

    475. 

  475. $FILTER_ATTRIBS = array("encode"=>"Strips,MIME=application/vnd.fmencoded,Encrypts",

    476. 

  476.                         "httpencode"=>"Strips,MIME=application/vnd.fmencoded,Encrypts",

    477. 

  477.                         "sslencode"=>"Strips,MIME=application/vnd.fmencoded,Encrypts",

    478. 

  478.                         "csv"=>"Strips,MIME=text/csv",);

    479. 

  479. 

    480. 

  480.             /* Help: http://www.tectite.com/fmdoc/check_for_new_version.php */

    481. 

  481. define("CHECK_FOR_NEW_VERSION",true);

    482. 

  482. define("CHECK_DAYS",30);

    483. 

  483. 

    484. 

  484.             /* Help: http://www.tectite.com/fmdoc/scratch_pad.php */

    485. 

  485. $SCRATCH_PAD = "";

    486. 

  486. 

    487. 

  487.             /* Help: http://www.tectite.com/fmdoc/cleanup_time.php */

    488. 

  488. $CLEANUP_TIME = 60;     // cleanup time in minutes

    489. 

  489. 

    490. 

  490.             /* Help: http://www.tectite.com/fmdoc/cleanup_chance.php */

    491. 

  491. $CLEANUP_CHANCE = 20;     // percentage probability that cleanup will be performed

    492. 

  492. 

    493. 

  493.             /* Help: http://www.tectite.com/fmdoc/pear_settings.php */

    494. 

  494. $PEAR_SMTP_HOST = "";

    495. 

  495. $PEAR_SMTP_PORT = 25;

    496. 

  496. $PEAR_SMTP_USER = "";

    497. 

  497. $PEAR_SMTP_PWD = "";

    498. 

  498. 

    499. 

  499.             /* Help: http://www.tectite.com/fmdoc/alert_on_user_error.php */

    500. 

  500. define("ALERT_ON_USER_ERROR",true);

    501. 

  501. 

    502. 

  502.             /* Help: http://www.tectite.com/fmdoc/enable_attack_detection.php */

    503. 

  503. define("ENABLE_ATTACK_DETECTION",true);

    504. 

  504. 

    505. 

  505.             /* Help: http://www.tectite.com/fmdoc/attack_detection_url.php */

    506. 

  506. define("ATTACK_DETECTION_URL","");

    507. 

  507. 

    508. 

  508.             /* Help: http://www.tectite.com/fmdoc/alert_on_attack_detection.php */

    509. 

  509. define("ALERT_ON_ATTACK_DETECTION",false);

    510. 

  510. 

    511. 

  511.             /* Help: http://www.tectite.com/fmdoc/attack_detection_mime.php */

    512. 

  512. define("ATTACK_DETECTION_MIME",true);

    513. 

  513. 

    514. 

  514.             /* Help: http://www.tectite.com/fmdoc/attack_detection_junk.php */

    515. 

  515. define("ATTACK_DETECTION_JUNK",false);

    516. 

  516. define("ATTACK_DETECTION_JUNK_CONSONANTS","bcdfghjklmnpqrstvwxz");

    517. 

  517. define("ATTACK_DETECTION_JUNK_VOWELS","aeiouy");

    518. 

  518. define("ATTACK_DETECTION_JUNK_CONSEC_CONSONANTS",5);

    519. 

  519. define("ATTACK_DETECTION_JUNK_CONSEC_VOWELS",4);

    520. 

  520. define("ATTACK_DETECTION_JUNK_TRIGGER",2);

    521. 

  521. $ATTACK_DETECTION_JUNK_LANG_STRIP = array(

    522. 

  522.     "aiia",  /* Hawaiian */

    523. 

  523.     "aeoa",  /* palaeoanthropic */

    524. 

  524.     "aeoe",  /* palaeoethnic */

    525. 

  525.     "ooee",  /* cooee */

    526. 

  526.     "oeia",  /* pharmacopoeia */

    527. 

  527.     "ioau",  /* radioautograph */

    528. 

  528.     "uaia",  /* guaiac */

    529. 

  529.     "ueou",  /* aqueous */

    530. 

  530.     "uiou",  /* obsequious */

    531. 

  531.     "queue", /* queue, queueing */

    532. 

  532.     "earth", /* earthquake, earthslide */

    533. 

  533.     "cks",   /* jockstrap, backscratcher */

    534. 

  534.     "ngth",  /* strengths, length */

    535. 

  535.     "ndths", /* thousandths */

    536. 

  536.     "ght",   /* nightclub, knightsbridge */

    537. 

  537.     "phth",  /* ophthalmology */

    538. 

  538.     "sch",   /* rothschild */

    539. 

  539.     "shch",  /* borshch */

    540. 

  540.     "scr",   /* corkscrew */

    541. 

  541.     "spr",   /* wingspread, offspring */

    542. 

  542.     "str",   /* armstrong, songstress */

    543. 

  543.     "sts",   /* bursts, postscript */

    544. 

  544.     "tch",   /* catchphrase, scratchproof */

    545. 

  545.     "thst",  /* northstar, birthstone */

    546. 

  546.     "http",  /* https, http */

    547. 

  547.     "html",  /* HTML, XHTML */

    548. 

  548.     );

    549. 

  549. $ATTACK_DETECTION_JUNK_IGNORE_FIELDS = array();

    550. 

  550.         

    551. 

  551. 

    552. 

  552.             /* Help: http://www.tectite.com/fmdoc/attack_detection_dups.php */

    553. 

  553. $ATTACK_DETECTION_DUPS = array("realname","address1","address2","country","zip",

    554. 

  554.                                 "phone","postcode","state","email");

    555. 

  555. 

    556. 

  556.             /* Help: http://www.tectite.com/fmdoc/attack_detection_specials.php */

    557. 

  557. define("ATTACK_DETECTION_SPECIALS",true);

    558. 

  558. 

    559. 

  559.             /* Help: http://www.tectite.com/fmdoc/attack_detection_specials.php */

    560. 

  560. $ATTACK_DETECTION_SPECIALS_ONLY_EMAIL = array("derive_fields","required",

    561. 

  561.                     "mail_options","good_url","bad_url","good_template",

    562. 

  562.                     "bad_template");

    563. 

  563. 

    564. 

  564.             /* Help: http://www.tectite.com/fmdoc/attack_detection_specials.php */

    565. 

  565. $ATTACK_DETECTION_SPECIALS_ANY_EMAIL = array("subject");

    566. 

  566. 

    567. 

  567.             /* Help: http://www.tectite.com/fmdoc/attack_detection_many_urls.php */

    568. 

  568. define("ATTACK_DETECTION_MANY_URLS",0);

    569. 

  569. 

    570. 

  570.             /* Help: http://www.tectite.com/fmdoc/attack_detection_many_url_fields.php */

    571. 

  571. define("ATTACK_DETECTION_MANY_URL_FIELDS",0);

    572. 

  572. 

    573. 

  573.             /* Help: http://www.tectite.com/fmdoc/attack_detection_url_patterns.php */

    574. 

  574. $ATTACK_DETECTION_URL_PATTERNS = array(

    575. 

  575.             '(^|[^-a-z_.0-9]+)(?<!@)([-a-z0-9]+\.)+(com|org|net|biz|info|name|pro|tel|asia|cat)\b',

    576. 

  576.             '(^|[^-a-z_.0-9]+)(?<!@)([-a-z0-9]+\.)+(com{0,1}|org|net)\.[a-z][a-z]\b');

    577. 

  577. 

    578. 

  578.             /* Help: http://www.tectite.com/fmdoc/attack_detection_ignore_errors.php */

    579. 

  579. define("ATTACK_DETECTION_IGNORE_ERRORS",false);

    580. 

  580. 

    581. 

  581.             /* Help: http://www.tectite.com/fmdoc/attack_detection_reverse_captcha.php */

    582. 

  582. $ATTACK_DETECTION_REVERSE_CAPTCHA = array();

    583. 

  583. 

    584. 

  584.             /* Help: http://www.tectite.com/fmdoc/geoip_lic.php */

    585. 

  585. $GEOIP_LIC = "";        // default - no GeoIP

    586. 

  586. 

    587. 

  587.             /* Help: http://www.tectite.com/fmdoc/zero_is_empty.php */

    588. 

  588. define("ZERO_IS_EMPTY",false);

    589. 

  589. 

    590. 

  590.             /* Help: http://www.tectite.com/fmdoc/session_name.php */

    591. 

  591. $SESSION_NAME = "";

    592. 

  592. 

    593. 

  593.             /* Help: http://www.tectite.com/fmdoc/session_access.php */

    594. 

  594. $SESSION_ACCESS = array();

    595. 

  595. 

    596. 

  596.             /* Help: http://www.tectite.com/fmdoc/destroy_session.php */

    597. 

  597. define("DESTROY_SESSION",true);

    598. 

  598. 

    599. 

  599.             /* Help: http://www.tectite.com/fmdoc/hook_dir.php */

    600. 

  600. $HOOK_DIR = "";

    601. 

  601. 

    602. 

  602. /* UPGRADE CONTROL

    603. 

  603. **

    604. 

  604. ** FILTERS:lt:8.04:merge:The FILTERS configuration has

    605. 

  605. ** been modified to include some new standard filters.:

    606. 

  606. **

    607. 

  607. ** FILTER_ATTRIBS:lt:8.04:no_keep:The FILTER_ATTRIBS configuration has

    608. 

  608. ** been modified to include new information about the standard filters.:

    609. 

  609. **

    610. 

  610. ** ATTACK_DETECTION_URL_PATTERNS:eq:8.02:no_keep:The ATTACK_DETECTION_URL_PATTERNS

    611. 

  611. ** configuration has been modified to fix a bug.:

    612. 

  612. **

    613. 

  613. ** FILTER_ATTRIBS:lt:4.00:no_keep:The FILTER_ATTRIBS configuration has

    614. 

  614. ** been modified to include new information about the standard filters.:

    615. 

  615. **

    616. 

  616. ** SET_REAL_DOCUMENT_ROOT:gt:4.07:copy_from=REAL_DOCUMENT_ROOT:The

    617. 

  617. ** REAL_DOCUMENT_ROOT configuration has been renamed to SET_REAL_DOCUMENT_ROOT.:

    618. 

  618. **

    619. 

  619. ** EMAIL_NAME:lt:6.01:no_keep:The EMAIL_NAME configuration has

    620. 

  620. ** been modified to match hyphens ('-') in email addresses.:

    621. 

  621. **

    622. 

  622. ** ZERO_IS_EMPTY:le:6.01:set_to=true:ZERO_IS_EMPTY has been

    623. 

  623. ** set to a value that duplicates previous behaviour.:

    624. 

  624. **

    625. 

  625. ** TEXT_SUBS:lt:8.30:no_keep:The TEXT_SUBS configuration has

    626. 

  626. ** been modified to be secure with new features released in this version.:

    627. 

  627. **

    628. 

  628. ** END OF CONTROL

    629. 

  629. */

    630. 

  630. 

    631. 

  631. /*****************************************************************************/

    632. 

  632. /* END OF CONFIGURATION (do not alter this line in any way!!!)               */

    633. 

  633. /*****************************************************************************/

    634. 

  634. 

    635. 

  635. //

    636. 

  636. // for Ajax allow GET method for cross site JSONP

    637. 

  637. //

    638. 

  638. if (IsAjax())

    639. 

  639.     $ALLOW_GET_METHOD = true;

    640. 

  640. 

    641. 

  641.     /*

    642. 

  642.      * Load an optional include file after the configuration.

    643. 

  643.      * You can use this to set variables or make adjustments

    644. 

  644.      * based on the results of the configuration section.

    645. 

  645.      */

    646. 

  646. @include("formmail-postconfig.inc.php");

    647. 

  647. 

    648. 

  648.     //

    649. 

  649.     // the following constants define all FormMail messages

    650. 

  650.     //

    651. 

  651. define('MSG_SCRIPT_VERSION',0);     // This script requires at least PHP version...

    652. 

  652. define('MSG_END_VERS_CHK',1);       // If you're happy...

    653. 

  653. define('MSG_VERS_CHK',2);           // A later version of FormMail is available...

    654. 

  654. define('MSG_CHK_FILE_ERROR',3);     // Unable to create check file...

    655. 

  655. define('MSG_UNK_VALUE_SPEC',4);     // derive_fields: unknown value specification...

    656. 

  656. define('MSG_INV_VALUE_SPEC',5);     // derive_fields: invalid value specification...

    657. 

  657. define('MSG_DERIVED_INVALID',6);    // Some derive_fields specifications...

    658. 

  658. define('MSG_INT_FORM_ERROR',7);     // Internal form error...

    659. 

  659. define('MSG_OPTIONS_INVALID',8);    // Some mail_options settings...

    660. 

  660. define('MSG_PLSWAIT_REDIR',9);      // Please wait while you are redirected...

    661. 

  661. define('MSG_IFNOT_REDIR',10);       // If you are not redirected...

    662. 

  662. define('MSG_PEAR_OBJ',11);          // Failed to create PEAR Mail object...

    663. 

  663. define('MSG_PEAR_ERROR',12);        // PEAR Mail error...

    664. 

  664. define('MSG_NO_FOPT_ADDR',13);      // You have specified "SendMailFOption"...

    665. 

  665. define('MSG_MORE_INFO',14);         // More information...

    666. 

  666. define('MSG_INFO_STOPPED',15);      // Extra alert information suppressed...

    667. 

  667. define('MSG_FM_ALERT',16);          // FormMail alert

    668. 

  668. define('MSG_FM_ERROR',17);          // FormMail script error

    669. 

  669. define('MSG_FM_ERROR_LINE',18);     // The following error occurred...

    670. 

  670. define('MSG_USERDATA_STOPPED',19);  // User data suppressed...

    671. 

  671. define('MSG_FILTERED',20);          // This alert has been filtered...

    672. 

  672. define('MSG_TEMPLATES',21);         // You must set either TEMPLATEDIR or TEMPLATEURL...

    673. 

  673. define('MSG_OPEN_TEMPLATE',22);     // Failed to open template...

    674. 

  674. define('MSG_ERROR_PROC',23);        // An error occurred while processing...

    675. 

  675. define('MSG_ALERT_DONE',24);        // Our staff have been alerted...

    676. 

  676. define('MSG_PLS_CONTACT',25);       // Please contact us directly...

    677. 

  677. define('MSG_APOLOGY',26);           // We apologize for any inconvenience...

    678. 

  678. define('MSG_ABOUT_FORMMAIL',27);    // Your form submission was processed by...

    679. 

  679. define('MSG_PREG_FAILED',28);       // preg_match_all failed in FindCRMFields...

    680. 

  680. define('MSG_URL_INVALID',29);       // CRM URL "$URL" is not valid...

    681. 

  681. define('MSG_URL_OPEN',30);          // Failed to open Customer Relationship...

    682. 

  682. define('MSG_CRM_FAILED',31);        // Failure report from CRM...

    683. 

  683. define('MSG_CRM_FORM_ERROR',32);    // Your form submission was not...

    684. 

  684. define('MSG_OR',33);                // "$ITEM1" or "$ITEM2"

    685. 

  685. define('MSG_NOT_BOTH',34);          // not both "$ITEM1" and "$ITEM2"

    686. 

  686. define('MSG_XOR',35);               // "$ITEM1" or "$ITEM2" (but not both)

    687. 

  687. define('MSG_IS_SAME_AS',36);        // "$ITEM1" is the same as "$ITEM2"

    688. 

  688. define('MSG_IS_NOT_SAME_AS',37);    // "$ITEM1" is not the same as "$ITEM2"

    689. 

  689. define('MSG_REQD_OPER',38);         // Operator "$OPER" is not valid for "required"

    690. 

  690. define('MSG_PAT_FAILED',39);        // Pattern operator "$OPER" failed: pattern...

    691. 

  691. define('MSG_COND_OPER',40);         // Operator "$OPER" is not valid...

    692. 

  692. define('MSG_INV_COND',41);          // Invalid "conditions" field...

    693. 

  693. define('MSG_COND_CHARS',42);        // The conditions field "$FLD" is not valid...

    694. 

  694. define('MSG_COND_INVALID',43);      // The conditions field "$FLD" is not valid...

    695. 

  695. define('MSG_COND_TEST_LONG',44);    // Field "$FLD" has too many components...

    696. 

  696. define('MSG_COND_IF_SHORT',45);     // Field "$FLD" has too few components for...

    697. 

  697. define('MSG_COND_IF_LONG',46);      // Field "$FLD" has too many components for...

    698. 

  698. define('MSG_COND_UNK',47);          // Field "$FLD" has an unknown command word...

    699. 

  699. define('MSG_MISSING',48);           // Missing "$ITEM"...

    700. 

  700. define('MSG_NEED_ARRAY',49);        // "$ITEM" must be an array...

    701. 

  701. define('MSG_SUBM_FAILED',50);       // Your form submission has failed...

    702. 

  702. define('MSG_FILTER_WRONG',51);      // Filter "$FILTER" is not properly...

    703. 

  703. define('MSG_FILTER_CONNECT',52);    // Could not connect to site "$SITE"...

    704. 

  704. define('MSG_FILTER_PARAM',53);      // Filter "$FILTER" has invalid parameter...

    705. 

  705. define('MSG_FILTER_OPEN_FILE',54);  // Filter "$FILTER" cannot open file...

    706. 

  706. define('MSG_FILTER_FILE_ERROR',55); // Filter "$FILTER": read error on file...

    707. 

  707. define('MSG_FILTER_READ_ERROR',56); // Filter '$filter' failed: read error...

    708. 

  708. define('MSG_FILTER_NOT_OK',57);     // Filter 'FILTER' failed...

    709. 

  709. define('MSG_FILTER_UNK',58);        // Unknown filter...

    710. 

  710. define('MSG_FILTER_CHDIR',59);      // Cannot chdir...

    711. 

  711. define('MSG_FILTER_NOTFOUND',60);   // Cannot execute...

    712. 

  712. define('MSG_FILTER_ERROR',61);      // Filter "$FILTER" failed...

    713. 

  713. define('MSG_SPARE',62);             // this value is now spare

    714. 

  714. define('MSG_TEMPLATE_ERRORS',63);   // Template "$NAME" caused the...

    715. 

  715. define('MSG_TEMPLATE_FAILED',64);   // Failed to process template "$NAME"...

    716. 

  716. define('MSG_MIME_PREAMBLE',65);     // (Your mail reader should not show this...

    717. 

  717. define('MSG_MIME_HTML',66);         // This message has been generated by FormMail...

    718. 

  718. define('MSG_FILE_OPEN_ERROR',67);   // Failed to open file "$NAME"...

    719. 

  719. define('MSG_ATTACH_DATA',68);       // Internal error: AttachFile requires...

    720. 

  720. define('MSG_PHP_HTML_TEMPLATES',69);    // HTMLTemplate option is only ...

    721. 

  721. define('MSG_PHP_FILE_UPLOADS',70);  // For security reasons, file upload...

    722. 

  722. define('MSG_FILE_UPLOAD',71);       // File upload attempt ignored...

    723. 

  723. define('MSG_FILE_UPLOAD_ATTACK',72);// Possible file upload attack...

    724. 

  724. define('MSG_PHP_PLAIN_TEMPLATES',73);// PlainTemplate option is only...

    725. 

  725. define('MSG_ATTACH_NAME',74);       // filter_options: Attach must contain a name...

    726. 

  726. define('MSG_PHP_BCC',75);           // Warning: BCC is probably not supported...

    727. 

  727. define('MSG_CSVCOLUMNS',76);        // The "csvcolumns" setting is not...

    728. 

  728. define('MSG_CSVFILE',77);           // The "csvfile" setting is not...

    729. 

  729. define('MSG_TARG_EMAIL_PAT_START',78);  // Warning: Your TARGET_EMAIL pattern...

    730. 

  730. define('MSG_TARG_EMAIL_PAT_END',79);    // Warning: Your TARGET_EMAIL pattern...

    731. 

  731. define('MSG_CONFIG_WARN',80);       // The following potential problems...

    732. 

  732. define('MSG_PHP_AUTORESP',81);      // Autorespond is only supported...

    733. 

  733. define('MSG_ALERT',82);             // This is a test alert message...

    734. 

  734. define('MSG_NO_DEF_ALERT',83);      // No DEF_ALERT value has been set....

    735. 

  735. define('MSG_TEST_SENT',84);         // Test message sent.  Check your email.....

    736. 

  736. define('MSG_TEST_FAILED',85);       // FAILED to send alert message...

    737. 

  737. define('MSG_NO_DATA_PAGE',86);      // This URL is a Form submission program...

    738. 

  738. define('MSG_REQD_ERROR',87);        // The form required some values that you...

    739. 

  739. define('MSG_COND_ERROR',88);        // Some of the values you provided...

    740. 

  740. define('MSG_CRM_FAILURE',89);       // The form submission did not succeed...

    741. 

  741. define('MSG_FOPTION_WARN',90);      // Warning: You've used SendMailFOption in...

    742. 

  742. define('MSG_NO_ACTIONS',91);        // The form has an internal error...

    743. 

  743. define('MSG_NO_RECIP',92);          // The form has an internal error...

    744. 

  744. define('MSG_INV_EMAIL',93);         // Invalid email addresses...

    745. 

  745. define('MSG_FAILED_SEND',94);       // Failed to send email...

    746. 

  746. define('MSG_ARESP_EMAIL',96);       // No "email" field was found. Autorespond...

    747. 

  747. define('MSG_ARESP_SUBJ',97);        // Your form submission...

    748. 

  748. define('MSG_LOG_NO_VERIMG',98);     // No VerifyImgString in session...

    749. 

  749. define('MSG_ARESP_NO_AUTH',99);     // Failed to obtain authorization...

    750. 

  750. define('MSG_LOG_NO_MATCH',100);     // User did not match image...

    751. 

  751. define('MSG_ARESP_NO_MATCH',101);   // Your entry did not match...

    752. 

  752. define('MSG_LOG_FAILED',102);       // Failed

    753. 

  753. define('MSG_ARESP_FAILED',103);     // Autoresponder failed

    754. 

  754. define('MSG_LOG_OK',104);           // OK

    755. 

  755. define('MSG_THANKS_PAGE',105);      // Thanks!  We've received your....

    756. 

  756. define('MSG_LOAD_MODULE',106);      // Cannot load module....

    757. 

  757. define('MSG_LOAD_FMCOMPUTE',107);   // Cannot load FMCompute....

    758. 

  758. define('MSG_REGISTER_MODULE',108);  // Cannot register module....

    759. 

  759. define('MSG_COMP_PARSE',109);       // These parse errors occurred....

    760. 

  760. define('MSG_COMP_REG_DATA',110);    // Failed to register data field....

    761. 

  761. define('MSG_COMP_ALERT',111);       // The following alert messages....

    762. 

  762. define('MSG_COMP_DEBUG',112);       // The following debug messages...

    763. 

  763. define('MSG_COMP_EXEC',113);        // The following errors occurred....

    764. 

  764. define('MSG_REG_FMCOMPUTE',114);    // Cannot register function...

    765. 

  765. define('MSG_USER_ERRORS',115);      // A number of errors occurred...

    766. 

  766. define('MSG_CALL_PARAM_COUNT',116); // Invalid parameter count...

    767. 

  767. define('MSG_CALL_UNK_FUNC',117);    // Unknown function...

    768. 

  768. define('MSG_SAVE_FILE',118);        // Failed to save file....

    769. 

  769. define('MSG_CHMOD',119);            // Failed to chmod file....

    770. 

  770. define('MSG_VERIFY_MISSING',120);   // Image verification string missing...

    771. 

  771. define('MSG_VERIFY_MATCH',121);     // Your entry did not match...

    772. 

  772. define('MSG_FILE_NAMES_INVALID',122);// Some file_names specifications...

    773. 

  773. define('MSG_FILE_NAMES_NOT_FILE',123);// Your file_names specification...

    774. 

  774. define('MSG_TEMPL_ALERT',124);       // The following alert messages....

    775. 

  775. define('MSG_TEMPL_DEBUG',125);       // The following debug messages...

    776. 

  776. define('MSG_TEMPL_PROC',126);        // The following errors occurred....

    777. 

  777. define('MSG_SAVE_FILE_EXISTS',127);  // Cannot save file....

    778. 

  778. define('MSG_EMPTY_ADDRESSES',128);   // $COUNT empty addresses

    779. 

  779. define('MSG_CALL_INVALID_PARAM',129); // Invalid parameter....

    780. 

  780. define('MSG_INI_PARSE_WARN',130);   // Warning: your INI

    781. 

  781. define('MSG_INI_PARSE_ERROR',131);  // The FormMail INI...

    782. 

  782. define('MSG_RECAPTCHA_MATCH',132);     // reCaptcha verification failed...

    783. 

  783. 

    784. 

  784. define('MSG_AND',133);              // "$ITEM1" and "$ITEM2"

    785. 

  785. define('MSG_NEXT_PLUS_GOOD',134);   // The form specifies both next_form and....

    786. 

  786. define('MSG_MULTIFORM',135);        // You must set either MULTIFORMDIR or MULTIFORMURL...

    787. 

  787. define('MSG_MULTIFORM_FAILED',136); // Failed to process multi-page form template "$NAME"...

    788. 

  788. define('MSG_NEED_THIS_FORM',137);   // Multi-page forms require "this_form" field...

    789. 

  789. define('MSG_NO_PHP_SELF',138);      // PHP on the server is not providing "PHP_SELF"

    790. 

  790. define('MSG_RETURN_URL_INVALID',139); // Return "$URL" is not valid...

    791. 

  791. define('MSG_GO_BACK',140);          // Cannot 'go back' if not a multi-page form...

    792. 

  792. define('MSG_OPEN_URL',141);         // Cannot open URL...

    793. 

  793. define('MSG_CANNOT_RETURN',142);    // Cannot return to page....

    794. 

  794. define('MSG_ATTACK_DETECTED',143);  // Server attack detected....

    795. 

  795. define('MSG_ATTACK_PAGE',144);      // Your form submission....

    796. 

  796. define('MSG_ATTACK_MIME_INFO',145); // The field "$FLD" contained...

    797. 

  797. define('MSG_ATTACK_DUP_INFO',146);  // The fields "$FLD1" and...

    798. 

  798. define('MSG_ATTACK_SPEC_INFO',147); // Special field "$FLD"...

    799. 

  799. define('MSG_NEED_SCRATCH_PAD',148); // You need to set SCRATCH_PAD...

    800. 

  800. define('MSG_MULTI_UPLOAD',149);     // File upload processing failed during multi-page form processing.

    801. 

  801. define('MSG_OPEN_SCRATCH_PAD',150); // Cannot open directory...

    802. 

  802. define('MSG_NO_NEXT_NUM_FILE',151); // You cannot use the %nextnum% feature...

    803. 

  803. define('MSG_NEXT_NUM_FILE',152);    // Cannot process next number...

    804. 

  804. define('MSG_ATTACK_MANYURL_INFO',153); // Field "$FLD"...

    805. 

  805. define('MSG_ATTACK_MANYFIELDS_INFO',154); // $NUM fields have URLs....

    806. 

  806. define('MSG_REV_CAP',155);           // ATTACK_DETECTION_REVERSE_CAPTCHA setting....

    807. 

  807. define('MSG_ATTACK_REV_CAP_INFO',156); // The field "$FLD" contained...

    808. 

  808. define('MSG_ATTACK_JUNK_INFO',157); // The field "$FLD" contained...

    809. 

  809. define('MSG_ARESP_EMPTY',158);      // The autoresponse...

    810. 

  810. define('MSG_LOG_RECAPTCHA',159);     // reCaptcha process failed...

    811. 

  811. 

    812. 

  812. define('MSG_URL_PARSE',160);        // URL parse failed

    813. 

  813. define('MSG_URL_SCHEME',161);       // Unsupported URL scheme...

    814. 

  814. define('MSG_SOCKET',162);           // Socket error ...

    815. 

  815. define('MSG_GETURL_OPEN',163);      // Open URL failed: ...

    816. 

  816. define('MSG_RESOLVE',164);          // Cannot resolve...

    817. 

  817. 

    818. 

  818. define('MSG_FORM_OK',170);          // Form Submission Succeeded

    819. 

  819. define('MSG_FORM_ERROR',171);       // Form Submission Error

    820. 

  820. define('MSG_GET_DISALLOWED',172);   // GET method has...

    821. 

  821.     //

    822. 

  822.     // The following are PHP's file upload error messages

    823. 

  823.     //

    824. 

  824. define('MSG_FILE_UPLOAD_ERR_UNK',180);  // Unknown error code.

    825. 

  825. define('MSG_FILE_UPLOAD_ERR1',181);     // The uploaded file exceeds the upload_max_filesize directive in php.ini.

    826. 

  826. define('MSG_FILE_UPLOAD_ERR2',182);     // The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the html form.

    827. 

  827. define('MSG_FILE_UPLOAD_ERR3',183);     // The uploaded file was only partially uploaded.

    828. 

  828. define('MSG_FILE_UPLOAD_ERR4',184);     // No file was uploaded.

    829. 

  829. define('MSG_FILE_UPLOAD_ERR6',186);     // Missing a temporary folder.

    830. 

  830. define('MSG_FILE_UPLOAD_ERR7',187);     // Failed to write file to disk.

    831. 

  831. define('MSG_FILE_UPLOAD_ERR8',188);     // File upload stopped by extension.

    832. 

  832. define('MSG_FILE_UPLOAD_SIZE',189);     // Uploaded file "$NAME" is too big...

    833. 

  833.                                         // (not a PHP error code - internal maximum file size error)

    834. 

  834. 

    835. 

  835.     //

    836. 

  836.     // following are for derive_fields functions

    837. 

  837.     //

    838. 

  838. define('MSG_DER_FUNC_ERROR',200);       // derive_fields: invalid function....

    839. 

  839. define('MSG_DER_FUNC_SIZE_FMT',201);    // function 'size' requires....

    840. 

  840. define('MSG_DER_FUNC_IF_FMT',202);      // function 'if' requires....

    841. 

  841. define('MSG_DER_FUNC_NEXTNUM_FMT',203); // function 'nextnum' requires....

    842. 

  842. define('MSG_DER_FUNC_EXT_FMT',204);     // function 'ext' requires....

    843. 

  843. define('MSG_DER_FUNC1_FMT',205);        // function 'FUNC' requires....

    844. 

  844. 

    845. 

  845. define('MSG_USER_ATTACK_JUNK',220);     // The following input ...

    846. 

  846. define('MSG_USER_ATTACK_REV_CAP',221);  // Your input ...

    847. 

  847. define('MSG_USER_ATTACK_DUP',222);      // You have ...

    848. 

  848. define('MSG_USER_ATTACK_MANY_URLS',223);// Your input ...

    849. 

  849. define('MSG_USER_ATTACK_MANY_URL_FIELDS',224);// Your input ...

    850. 

  850. 

    851. 

  851. // <A NAME="MessageNumbers"> Jump to: <A HREF="#BuiltinMessages">

    852. 

  852. 

    853. 

  853.     //

    854. 

  854.     // Return true if using the built-in language

    855. 

  855.     //

    856. 

  856. function IsBuiltInLanguage()

    857. 

  857. {

    858. 

  858.     global  $sLangID;

    859. 

  859. 

    860. 

  860.     return (strpos($sLangID,"builtin") !== false);

    861. 

  861. }

    862. 

  862. 

    863. 

  863. $sSavePath = "";

    864. 

  864. $bPathSaved = false;

    865. 

  865.     //

    866. 

  866.     // Set include path to include the given directory.

    867. 

  867.     //

    868. 

  868. function AddIncludePath($s_dir = ".")

    869. 

  869. {

    870. 

  870.     global  $sSavePath,$bPathSaved;

    871. 

  871. 

    872. 

  872.     $s_path = ini_get('include_path');

    873. 

  873.     $i_path_len = strlen($s_path);

    874. 

  874.     $s_sep = IsServerWindows() ? ";" : ":";     // get path separator

    875. 

  875.         //

    876. 

  876.         // look for it in the include_path

    877. 

  877.         //

    878. 

  878.     $b_found = false;

    879. 

  879.     $i_pos = 0;

    880. 

  880.     $i_len = strlen($s_dir);

    881. 

  881.     while (!$b_found && ($i_pos = strpos($s_path,$s_dir,$i_pos)) !== false)

    882. 

  882.     {

    883. 

  883.         if ($i_pos == 0)

    884. 

  884.         {

    885. 

  885.             if ($i_len == $i_path_len)

    886. 

  886.                 $b_found = true;        // the path only has $s_dir

    887. 

  887.             elseif ($s_path[$i_len] == $s_sep)

    888. 

  888.                 $b_found = true;

    889. 

  889.         }

    890. 

  890.         elseif ($s_path[$i_pos-1] == $s_sep &&

    891. 

  891.                     ($i_pos + $i_len == $i_path_len ||

    892. 

  892.                     $s_path[$i_pos + $i_len] == $s_sep))

    893. 

  893.                 $b_found = true;

    894. 

  894.         if (!$b_found)

    895. 

  895.             $i_pos++;

    896. 

  896.     }

    897. 

  897.     if (!$b_found)

    898. 

  898.     {

    899. 

  899.             //

    900. 

  900.             // allow multiple calls, but only store the original path once

    901. 

  901.             //

    902. 

  902.         if (!$bPathSaved)

    903. 

  903.             $sSavePath = $s_path;

    904. 

  904.         if (empty($s_path))

    905. 

  905.             $s_path = $s_dir;

    906. 

  906.         else

    907. 

  907.                 //

    908. 

  908.                 // prepend the directory

    909. 

  909.                 //

    910. 

  910.             $s_path = $s_dir.$s_sep.$s_path;

    911. 

  911.         ini_set('include_path',$s_path);

    912. 

  912.         $bPathSaved = true;

    913. 

  913.     }

    914. 

  914. }

    915. 

  915. 

    916. 

  916.     //

    917. 

  917.     // Reset the include path after a call to AddIncludePath.

    918. 

  918.     //

    919. 

  919. function ResetIncludePath()

    920. 

  920. {

    921. 

  921.     global  $sSavePath,$bPathSaved;

    922. 

  922. 

    923. 

  923.     if ($bPathSaved)

    924. 

  924.     {

    925. 

  925.         ini_set('include_path',$sSavePath);

    926. 

  926.         $bPathSaved = false;

    927. 

  927.     }

    928. 

  928. }

    929. 

  929. 

    930. 

  930.     //

    931. 

  931.     // Load a language file

    932. 

  932.     //

    933. 

  933. function LoadLanguageFile()

    934. 

  934. {

    935. 

  935.     global  $aMessages,$sLangID,$sHTMLCharSet;

    936. 

  936. 

    937. 

  937.     AddIncludePath();

    938. 

  938.     if (!@include("language.inc.php"))

    939. 

  939.         @include("language.inc");

    940. 

  940.     ResetIncludePath();

    941. 

  941.     if (isset($sHTMLCharSet) && $sHTMLCharSet !== "")

    942. 

  942.         header("Content-Type: text/html; charset=$sHTMLCharSet");

    943. 

  943. }

    944. 

  944. 

    945. 

  945.     //

    946. 

  946.     // Load the messages array from the default language, and then

    947. 

  947.     // override with an optional language file.

    948. 

  948.     // Note: all messages get the MNUM parameter sent which they can use.

    949. 

  949.     // If they don't use it, the message number is appended.

    950. 

  950.     //

    951. 

  951. function LoadBuiltinLanguage()

    952. 

  952. {

    953. 

  953.     global  $aMessages,$sLangID;

    954. 

  954. 

    955. 

  955.     $sLangID = "English (builtin)";

    956. 

  956.         // MSG_SCRIPT_VERSION is shown if the PHP version is too old to run

    957. 

  957.         // FormMail

    958. 

  958.         // Parameters:

    959. 

  959.         //  $PHPREQ     is the minimum required PHP version

    960. 

  960.         //  $PHPVERS    is  the version the server currently has installed.

    961. 

  961.     $aMessages[MSG_SCRIPT_VERSION] = 'This script requires at least PHP version '.

    962. 

  962.                                      '$PHPREQ.  You have PHP version $PHPVERS.';

    963. 

  963. 

    964. 

  964.         // MSG_END_VERS_CHK is sent at the end of an Alert message when

    965. 

  965.         // FormMail detects that there's a newer version available

    966. 

  966.         // Parameters: none

    967. 

  967.     $aMessages[MSG_END_VERS_CHK] =  '***************************************************\n'.

    968. 

  968.                                     'If you are happy with your current version and want\n'.

    969. 

  969.                                     'to stop these reminders, edit formmail.php and\n'.

    970. 

  970.                                     'set CHECK_FOR_NEW_VERSION to false.\n'.

    971. 

  971.                                     '***************************************************\n';

    972. 

  972. 

    973. 

  973.         // MSG_VERS_CHK is sent in an Alert message when

    974. 

  974.         // FormMail detects that there's a newer version available

    975. 

  975.         // Parameters:

    976. 

  976.         //  $TECTITE    the website to go to

    977. 

  977.         //  $FM_VERS    the current FormMail version

    978. 

  978.         //  $NEWVERS    the new FormMail version that's available

    979. 

  979.     $aMessages[MSG_VERS_CHK] =  'A later version of FormMail is available from $TECTITE.\n'.

    980. 

  980.                                 'You are currently using version $FM_VERS.\n'.

    981. 

  981.                                 'The new version available is $NEWVERS.\n';

    982. 

  982. 

    983. 

  983.         // MSG_CHK_FILE_ERROR is sent in an Alert message when

    984. 

  984.         // FormMail cannot create a file to record the time of version check.

    985. 

  985.         // Parameters:

    986. 

  986.         //  $FILE   the file name that could not be created

    987. 

  987.         //  $ERROR  the actual error message

    988. 

  988.     $aMessages[MSG_CHK_FILE_ERROR] = 'Unable to create check file "$FILE": $ERROR';

    989. 

  989. 

    990. 

  990.         // MSG_UNK_VALUE_SPEC is sent in an Alert message when

    991. 

  991.         // a form uses an unknown value specification in derive_fields.

    992. 

  992.         // Parameters:

    993. 

  993.         //  $SPEC   the unknown value specification

    994. 

  994.         //  $MSG    additional message

    995. 

  995.     $aMessages[MSG_UNK_VALUE_SPEC] = 'derive_fields: unknown value specification '.

    996. 

  996.                                      '"$SPEC"$MSG';

    997. 

  997. 

    998. 

  998.         // MSG_INV_VALUE_SPEC is sent in an Alert message when

    999. 

  999.         // a form uses a value specification in derive_fields that's

    1000. 

  1000.         // formatted incorrectly (missing terminating '%')

    1001. 

  1001.         // Parameters:

    1002. 

  1002.         //  $SPEC   the invalid value specification

    1003. 

  1003.     $aMessages[MSG_INV_VALUE_SPEC] = 'derive_fields: invalid value specification '.

    1004. 

  1004.                                      '"$SPEC" (possibly missing a "%")';

    1005. 

  1005. 

    1006. 

  1006.         // MSG_DERIVED_INVALID is sent in an Alert message when

    1007. 

  1007.         // a form's derive_fields setting has errors

    1008. 

  1008.         // Parameters: none

    1009. 

  1009.         // A list of errors is appended on separate lines

    1010. 

  1010.     $aMessages[MSG_DERIVED_INVALID] = 'Some derive_fields specifications are invalid $MNUM:\n';

    1011. 

  1011. 

    1012. 

  1012.         // MSG_INT_FORM_ERROR is sent in an Alert message and displayed

    1013. 

  1013.         // to the form user

    1014. 

  1014.         // Parameters: none

    1015. 

  1015.     $aMessages[MSG_INT_FORM_ERROR] = 'Internal form error';

    1016. 

  1016. 

    1017. 

  1017.         // MSG_OPTIONS_INVALID is sent in an Alert message when

    1018. 

  1018.         // a form's options settings are invalid.  This applies to

    1019. 

  1019.         // mail_options, filter_options, crm_options, and autorespond

    1020. 

  1020.         // Parameters:

    1021. 

  1021.         //  $OPT    the name of the options field

    1022. 

  1022.         // A list of errors is appended on separate lines

    1023. 

  1023.     $aMessages[MSG_OPTIONS_INVALID] = 'Some $OPT settings are undefined $MNUM:\n';

    1024. 

  1024. 

    1025. 

  1025.         // MSG_PLSWAIT_REDIR is shown to the user for a redirect

    1026. 

  1026.         // with JavaScript

    1027. 

  1027.         // Parameters: none

    1028. 

  1028.     $aMessages[MSG_PLSWAIT_REDIR] = 'Please wait while you are redirected...';

    1029. 

  1029. 

    1030. 

  1030.         // MSG_IFNOT_REDIR is shown to the user for a redirect

    1031. 

  1031.         // with JavaScript

    1032. 

  1032.         // Parameters:

    1033. 

  1033.         //  $URL    the URL to redirect to

    1034. 

  1034.     $aMessages[MSG_IFNOT_REDIR] = 'If you are not automatically redirected, '.

    1035. 

  1035.                                   'please <a href="$URL">click here</a>.';

    1036. 

  1036. 

    1037. 

  1037.         // MSG_PEAR_OBJ is shown to the user if the PEAR Mail object

    1038. 

  1038.         // cannot be created

    1039. 

  1039.         // Parameters: none

    1040. 

  1040.     $aMessages[MSG_PEAR_OBJ] = 'Failed to create PEAR Mail object';

    1041. 

  1041. 

    1042. 

  1042.         // MSG_PEAR_ERROR is sent in an Alert message if the PEAR Mail processing

    1043. 

  1043.         // reports an error

    1044. 

  1044.         // Parameters:

    1045. 

  1045.         //  $MSG    the error message from PEAR

    1046. 

  1046.     $aMessages[MSG_PEAR_ERROR] = 'PEAR Mail error: $MSG';

    1047. 

  1047. 

    1048. 

  1048.         // MSG_NO_FOPT_ADDR is sent in an Alert message SendMailFOption is

    1049. 

  1049.         // specified in the form and no email address has been provided

    1050. 

  1050.         // Parameters: none

    1051. 

  1051.     $aMessages[MSG_NO_FOPT_ADDR] = 'You have specified "SendMailFOption" in your '.

    1052. 

  1052.                                    'form, but there is no email address to use';

    1053. 

  1053. 

    1054. 

  1054.         // MSG_MORE_INFO is sent in an Alert message on a line by itself, just

    1055. 

  1055.         // before extra information about the FormMail processing that may have

    1056. 

  1056.         // led to the alert message

    1057. 

  1057.         // Parameters: none

    1058. 

  1058.     $aMessages[MSG_MORE_INFO] = 'More information:';

    1059. 

  1059. 

    1060. 

  1060.         // MSG_INFO_STOPPED is sent in an Alert message to say that extra

    1061. 

  1061.         // alert information has been suppressed because of potential security

    1062. 

  1062.         // problems with showing it.

    1063. 

  1063.         // Parameters: none

    1064. 

  1064.     $aMessages[MSG_INFO_STOPPED] = '(Extra alert information suppressed for '.

    1065. 

  1065.                                    'security purposes. $MNUM)';

    1066. 

  1066. 

    1067. 

  1067.         // MSG_FM_ALERT is sent as the subject line of an Alert message

    1068. 

  1068.         // Parameters: none

    1069. 

  1069.     $aMessages[MSG_FM_ALERT] = 'FormMail alert';

    1070. 

  1070. 

    1071. 

  1071.         // MSG_FM_ERROR is sent as the subject line of an Alert message

    1072. 

  1072.         // Parameters: none

    1073. 

  1073.     $aMessages[MSG_FM_ERROR] = 'FormMail script error';

    1074. 

  1074. 

    1075. 

  1075.         // MSG_FM_ERROR_LINE is sent in an Alert message on a

    1076. 

  1076.         // separate line to introduce the actual error message

    1077. 

  1077.         // Parameters: none

    1078. 

  1078.     $aMessages[MSG_FM_ERROR_LINE] = 'The following error occurred in FormMail $MNUM:';

    1079. 

  1079. 

    1080. 

  1080.         // MSG_USERDATA_STOPPED is sent in an Alert message to say that the

    1081. 

  1081.         // user's data has been suppressed because of potential security

    1082. 

  1082.         // problems with showing it.

    1083. 

  1083.         // Parameters: none

    1084. 

  1084.     $aMessages[MSG_USERDATA_STOPPED] = '(User data suppressed for security '.

    1085. 

  1085.                                        'purposes. $MNUM)';

    1086. 

  1086. 

    1087. 

  1087.         // MSG_FILTERED is sent in an Alert message to show what filter

    1088. 

  1088.         // has been used on the message

    1089. 

  1089.         // Parameters:

    1090. 

  1090.         //  $FILTER     the name of the filter

    1091. 

  1091.     $aMessages[MSG_FILTERED] = 'This alert has been filtered through "$FILTER" '.

    1092. 

  1092.                                'for security purposes.';

    1093. 

  1093. 

    1094. 

  1094.         // MSG_TEMPLATES is sent in an Alert message when a form tries

    1095. 

  1095.         // to use a template, but templates have not been configured in

    1096. 

  1096.         // formmail.php

    1097. 

  1097.         // Parameters: none

    1098. 

  1098.     $aMessages[MSG_TEMPLATES] = 'You must set either TEMPLATEDIR or TEMPLATEURL '.

    1099. 

  1099.                                 'in formmail.php before you can specify '.

    1100. 

  1100.                                 'templates in your forms.';

    1101. 

  1101. 

    1102. 

  1102.         // MSG_OPEN_TEMPLATE is sent in an Alert message when FormMail cannot

    1103. 

  1103.         // open a template file

    1104. 

  1104.         // Parameters:

    1105. 

  1105.         //  $NAME   the name of the template file

    1106. 

  1106.         //  $ERROR  information about the error

    1107. 

  1107.     $aMessages[MSG_OPEN_TEMPLATE] = 'Failed to open template "$NAME" $MNUM: $ERROR';

    1108. 

  1108. 

    1109. 

  1109.         // MSG_ERROR_PROC is shown to the user as part of an error

    1110. 

  1110.         // page.  This message introduces the error.

    1111. 

  1111.         // Parameters: none

    1112. 

  1112.     $aMessages[MSG_ERROR_PROC] = 'An error occurred while processing the '.

    1113. 

  1113.                                  'form $MNUM.\n\n';

    1114. 

  1114. 

    1115. 

  1115.         // MSG_ALERT_DONE is shown to the user as part of an error

    1116. 

  1116.         // page if an Alert message has been sent to the website owner.

    1117. 

  1117.         // Parameters:

    1118. 

  1118.         //  SERVER      the name of the server (website)

    1119. 

  1119.     $aMessages[MSG_ALERT_DONE] = 'The staff at $SERVER have been alerted to the error $MNUM.\n';

    1120. 

  1120. 

    1121. 

  1121.         // MSG_PLS_CONTACT is shown to the user as part of an error

    1122. 

  1122.         // page if an Alert message could *not* be sent to the website owner.

    1123. 

  1123.         // Parameters:

    1124. 

  1124.         //  SERVER      the name of the server (website)

    1125. 

  1125.     $aMessages[MSG_PLS_CONTACT] = 'Please contact us ($SERVER) directly since this form '.

    1126. 

  1126.                                   'is not working $MNUM.\n';

    1127. 

  1127. 

    1128. 

  1128.         // MSG_APOLOGY is shown to the user as part of an error

    1129. 

  1129.         // page as an apology for a problem with the form.

    1130. 

  1130.         // Parameters:

    1131. 

  1131.         //  SERVER      the name of the server (website)

    1132. 

  1132.     $aMessages[MSG_APOLOGY] = '$SERVER apologizes for any inconvenience this error '.

    1133. 

  1133.                               'may have caused.';

    1134. 

  1134. 

    1135. 

  1135.         // MSG_ABOUT_FORMMAIL is shown to the user at the foot of pages

    1136. 

  1136.         // generated by FormMail (e.g. the default "Thanks" page and default

    1137. 

  1137.         // error page).

    1138. 

  1138.         // Parameters:

    1139. 

  1139.         //  $FM_VERS    the FormMail version number

    1140. 

  1140.         //  $TECTITE    www.tectite.com

    1141. 

  1141.     $aMessages[MSG_ABOUT_FORMMAIL] = 'Your form submission was processed by '.

    1142. 

  1142.                                      '<a href="http://$TECTITE/">FormMail</a> '.

    1143. 

  1143.                                      '($FM_VERS), a PHP script available from '.

    1144. 

  1144.                                      '<a href="http://$TECTITE/">$TECTITE</a>.';

    1145. 

  1145. 

    1146. 

  1146.         // MSG_PREG_FAILED is sent in an Alert message if the TectiteCRM

    1147. 

  1147.         // system failed to return the expected result.

    1148. 

  1148.         // Parameters: none

    1149. 

  1149.     $aMessages[MSG_PREG_FAILED] = 'preg_match_all failed in FindCRMFields';

    1150. 

  1150. 

    1151. 

  1151.         // MSG_URL_INVALID is sent in an Alert message if the specified

    1152. 

  1152.         // URL for TectiteCRM is not valid according to the TARGET_URLS

    1153. 

  1153.         // configuration setting

    1154. 

  1154.         // Parameters:

    1155. 

  1155.         //  $URL        the invalid URL

    1156. 

  1156.     $aMessages[MSG_URL_INVALID] = 'The URL "$URL" to access the Customer '.

    1157. 

  1157.                                   'Relationship Management System is not valid '.

    1158. 

  1158.                                   '(see TARGET_URLS in formmail.php)';

    1159. 

  1159. 

    1160. 

  1160.         // MSG_URL_OPEN is sent in an Alert message if the specified

    1161. 

  1161.         // URL for TectiteCRM cannot be opened

    1162. 

  1162.         // Parameters:

    1163. 

  1163.         //  $URL    the invalid URL

    1164. 

  1164.         //  $ERROR  information about the error

    1165. 

  1165.     $aMessages[MSG_URL_OPEN] = 'Failed to open Customer Relationship '.

    1166. 

  1166.                                'Management System URL "$URL" $MNUM: $ERROR';

    1167. 

  1167. 

    1168. 

  1168.         // MSG_CRM_FAILED is sent in an Alert message if the TectiteCRM

    1169. 

  1169.         // system doesn't return an OK message

    1170. 

  1170.         // Parameters:

    1171. 

  1171.         //  $URL    the invalid URL

    1172. 

  1172.         //  $MSG    more information

    1173. 

  1173.     $aMessages[MSG_CRM_FAILED] = 'Failure report from Customer Relationship '.

    1174. 

  1174.                                  'Management System (url="$URL") $MNUM: $MSG';

    1175. 

  1175. 

    1176. 

  1176.         // MSG_CRM_FORM_ERROR is shown to the user if the information

    1177. 

  1177.         // passed to TectiteCRM was not accepted

    1178. 

  1178.         // Parameters: none

    1179. 

  1179.     $aMessages[MSG_CRM_FORM_ERROR] = 'Your form submission was not accepted';

    1180. 

  1180. 

    1181. 

  1181.         // MSG_AND is shown to the user; it shows two items separated

    1182. 

  1182.         // by "and"

    1183. 

  1183.         // Parameters:

    1184. 

  1184.         //  $ITEM1      the first item

    1185. 

  1185.         //  $ITEM2      the second item

    1186. 

  1186.     $aMessages[MSG_AND] = '"$ITEM1" and "$ITEM2"';

    1187. 

  1187. 

    1188. 

  1188.         // MSG_OR is shown to the user; it shows two items separated

    1189. 

  1189.         // by "or"

    1190. 

  1190.         // Parameters:

    1191. 

  1191.         //  $ITEM1      the first item

    1192. 

  1192.         //  $ITEM2      the second item

    1193. 

  1193.     $aMessages[MSG_OR] = '"$ITEM1" or "$ITEM2"';

    1194. 

  1194. 

    1195. 

  1195.         // MSG_NOT_BOTH is shown to the user; it shows two items that must

    1196. 

  1196.         // be specified together

    1197. 

  1197.         // Parameters:

    1198. 

  1198.         //  $ITEM1      the first item

    1199. 

  1199.         //  $ITEM2      the second item

    1200. 

  1200.     $aMessages[MSG_NOT_BOTH] = 'not both "$ITEM1" and "$ITEM2"';

    1201. 

  1201. 

    1202. 

  1202.         // MSG_XOR is shown to the user; it shows two items that must

    1203. 

  1203.         // not be specified together

    1204. 

  1204.         // Parameters:

    1205. 

  1205.         //  $ITEM1      the first item

    1206. 

  1206.         //  $ITEM2      the second item

    1207. 

  1207.     $aMessages[MSG_XOR] = '"$ITEM1" or "$ITEM2" (but not both)';

    1208. 

  1208. 

    1209. 

  1209.         // MSG_IS_SAME_AS is shown to the user; it shows two items that must

    1210. 

  1210.         // not be the same value

    1211. 

  1211.         // Parameters:

    1212. 

  1212.         //  $ITEM1      the first item

    1213. 

  1213.         //  $ITEM2      the second item

    1214. 

  1214.     $aMessages[MSG_IS_SAME_AS] = '"$ITEM1" is the same as "$ITEM2"';

    1215. 

  1215. 

    1216. 

  1216.         // MSG_IS_NOT_SAME_AS is shown to the user; it shows two items that must

    1217. 

  1217.         // be the same value

    1218. 

  1218.         // Parameters:

    1219. 

  1219.         //  $ITEM1      the first item

    1220. 

  1220.         //  $ITEM2      the second item

    1221. 

  1221.     $aMessages[MSG_IS_NOT_SAME_AS] = '"$ITEM1" is not the same as "$ITEM2"';

    1222. 

  1222. 

    1223. 

  1223.         // MSG_REQD_OPER is sent in an Alert message when an unknown

    1224. 

  1224.         // operator has been used in a "required" specification

    1225. 

  1225.         // Parameters:

    1226. 

  1226.         //  $OPER       the unknown operator

    1227. 

  1227.     $aMessages[MSG_REQD_OPER] = 'Operator "$OPER" is not valid for "required"';

    1228. 

  1228. 

    1229. 

  1229.         // MSG_PAT_FAILED is sent in an Alert message when a "conditions" pattern

    1230. 

  1230.         // match has not matched anything (this isn't necessarily an error)

    1231. 

  1231.         // Parameters:

    1232. 

  1232.         //  $OPER       the "conditions" operator

    1233. 

  1233.         //  $PAT        the "conditions" pattern

    1234. 

  1234.         //  $VALUE      the value that was searched

    1235. 

  1235.     $aMessages[MSG_PAT_FAILED] = 'Pattern operator "$OPER" failed: pattern '.

    1236. 

  1236.                                  '"$PAT", value searched was "$VALUE".';

    1237. 

  1237. 

    1238. 

  1238.         // MSG_COND_OPER is sent in an Alert message when a "conditions"

    1239. 

  1239.         // operator is not value

    1240. 

  1240.         // Parameters:

    1241. 

  1241.         //  $OPER       the "conditions" operator

    1242. 

  1242.     $aMessages[MSG_COND_OPER] = 'Operator "$OPER" is not valid for "conditions"';

    1243. 

  1243. 

    1244. 

  1244.         // MSG_INV_COND is sent in an Alert message when a "conditions"

    1245. 

  1245.         // field is not valid

    1246. 

  1246.         // Parameters:

    1247. 

  1247.         //  FLD     the field name

    1248. 

  1248.     $aMessages[MSG_INV_COND] = 'Invalid "conditions" field "$FLD" - not a string or array.';

    1249. 

  1249. 

    1250. 

  1250.         // MSG_COND_CHARS is sent in an Alert message when a "conditions"

    1251. 

  1251.         // field is missing the mandatory first 2 characters (the separators)

    1252. 

  1252.         // Parameters:

    1253. 

  1253.         //  FLD     the field name

    1254. 

  1254.         //  COND    the conditions field value

    1255. 

  1255.     $aMessages[MSG_COND_CHARS] = 'The conditions field "$FLD" is not valid. '.

    1256. 

  1256.                                  'You must provide the two separator '.

    1257. 

  1257.                                  'characters at the beginning. You had "$COND".';

    1258. 

  1258. 

    1259. 

  1259.         // MSG_COND_INVALID is sent in an Alert message when a "conditions"

    1260. 

  1260.         // field has the wrong format

    1261. 

  1261.         // Parameters:

    1262. 

  1262.         //  FLD     the field name

    1263. 

  1263.         //  COND    the conditions field value

    1264. 

  1264.         //  SEP     the internal separator character for the field.

    1265. 

  1265.     $aMessages[MSG_COND_INVALID] = 'The conditions field "$FLD" is not valid. '.

    1266. 

  1266.                                    'There must be at least 5 components '.

    1267. 

  1267.                                    'separated by "$SEP". Your value was "$COND".';

    1268. 

  1268. 

    1269. 

  1269.         // MSG_COND_TEST_LONG is sent in an Alert message when a "conditions"

    1270. 

  1270.         // TEST value has too many components

    1271. 

  1271.         // Parameters:

    1272. 

  1272.         //  FLD     the field name

    1273. 

  1273.         //  COND    the conditions field value

    1274. 

  1274.         //  SEP     the list separator character for the field.

    1275. 

  1275.     $aMessages[MSG_COND_TEST_LONG] = 'Field "$FLD" has too many components for '.

    1276. 

  1276.                                      'a "TEST" command: "$COND".\nAre you missing '.

    1277. 

  1277.                                      'a "$SEP"?';

    1278. 

  1278. 

    1279. 

  1279.         // MSG_COND_IF_SHORT is sent in an Alert message when a "conditions"

    1280. 

  1280.         // IF value has too few components

    1281. 

  1281.         // Parameters:

    1282. 

  1282.         //  FLD     the field name

    1283. 

  1283.         //  COND    the conditions field value

    1284. 

  1284.         //  SEP     the internal separator character for the field.

    1285. 

  1285.     $aMessages[MSG_COND_IF_SHORT] = 'Field "$FLD" has too few components for '.

    1286. 

  1286.                                     'an "IF" command: "$COND".\nThere must be '.

    1287. 

  1287.                                     'at least 6 components separated by "$SEP"';

    1288. 

  1288. 

    1289. 

  1289.         // MSG_COND_IF_LONG is sent in an Alert message when a "conditions"

    1290. 

  1290.         // IF value has too many components

    1291. 

  1291.         // Parameters:

    1292. 

  1292.         //  FLD     the field name

    1293. 

  1293.         //  COND    the conditions field value

    1294. 

  1294.         //  SEP     the list separator character for the field.

    1295. 

  1295.     $aMessages[MSG_COND_IF_LONG] = 'Field "$FLD" has too many components for '.

    1296. 

  1296.                                    'an "IF" command: "$COND".\nAre you missing '.

    1297. 

  1297.                                    'a "$SEP"?';

    1298. 

  1298. 

    1299. 

  1299.         // MSG_COND_UNK is sent in an Alert message when a "conditions"

    1300. 

  1300.         // value has an unknown command

    1301. 

  1301.         // Parameters:

    1302. 

  1302.         //  FLD     the field name

    1303. 

  1303.         //  COND    the conditions field value

    1304. 

  1304.         //  CMD     the unknown command

    1305. 

  1305.     $aMessages[MSG_COND_UNK] = 'Field "$FLD" has an unknown command word '.

    1306. 

  1306.                                '"$CMD": "$COND".';

    1307. 

  1307. 

    1308. 

  1308.         // MSG_MISSING is sent in an Alert message when

    1309. 

  1309.         // a socket filter is incorrectly defined

    1310. 

  1310.         // Parameters:

    1311. 

  1311.         //  ITEM    the missing item

    1312. 

  1312.     $aMessages[MSG_MISSING] = 'Missing "$ITEM"';

    1313. 

  1313. 

    1314. 

  1314.         // MSG_NEED_ARRAY is sent in an Alert message when

    1315. 

  1315.         // a socket filter is incorrectly defined

    1316. 

  1316.         // Parameters:

    1317. 

  1317.         //  ITEM    the item that should be an array

    1318. 

  1318.     $aMessages[MSG_NEED_ARRAY] = '"$ITEM" must be an array';

    1319. 

  1319. 

    1320. 

  1320.         // MSG_SUBM_FAILED is shown to the user when an internal error

    1321. 

  1321.         // as occurred and that error is not to be shown

    1322. 

  1322.         // Parameters: none

    1323. 

  1323.     $aMessages[MSG_SUBM_FAILED] = 'Your form submission has failed due to '.

    1324. 

  1324.                                   'an error on our server.';

    1325. 

  1325. 

    1326. 

  1326.         // MSG_FILTER_WRONG is sent in an Alert message when

    1327. 

  1327.         // a socket filter is incorrectly defined

    1328. 

  1328.         // Parameters:

    1329. 

  1329.         //  FILTER  the filter name

    1330. 

  1330.         //  ERRORS  a string containing a list of errors

    1331. 

  1331.     $aMessages[MSG_FILTER_WRONG] = 'Filter "$FILTER" is not properly defined: '.

    1332. 

  1332.                                    '$ERRORS';

    1333. 

  1333. 

    1334. 

  1334.         // MSG_FILTER_CONNECT is sent in an Alert message when FormMail

    1335. 

  1335.         // cannot connect to a socket filter

    1336. 

  1336.         // Parameters:

    1337. 

  1337.         //  FILTER  the filter name

    1338. 

  1338.         //  SITE    the site

    1339. 

  1339.         //  ERRNUM  socket error number

    1340. 

  1340.         //  ERRSTR  socket error message

    1341. 

  1341.     $aMessages[MSG_FILTER_CONNECT] = 'Could not connect to site "$SITE" '.

    1342. 

  1342.                                      'for filter "$FILTER" ($ERRNUM): $ERRSTR';

    1343. 

  1343. 

    1344. 

  1344.         // MSG_FILTER_PARAM is sent in an Alert message when a socket

    1345. 

  1345.         // filter has an invalid parameter specification

    1346. 

  1346.         // Parameters:

    1347. 

  1347.         //  FILTER  the filter name

    1348. 

  1348.         //  NUM     parameter number

    1349. 

  1349.         //  NAME    parameter name

    1350. 

  1350.     $aMessages[MSG_FILTER_PARAM] = 'Filter "$FILTER" has invalid parameter '.

    1351. 

  1351.                                    '#$NUM: no "$NAME"';

    1352. 

  1352. 

    1353. 

  1353.         // MSG_FILTER_OPEN_FILE is sent in an Alert message when a socket

    1354. 

  1354.         // filter cannot open the required file

    1355. 

  1355.         // Parameters:

    1356. 

  1356.         //  FILTER  the filter name

    1357. 

  1357.         //  FILE    the file that could not be opened

    1358. 

  1358.         //  ERROR   the error message

    1359. 

  1359.     $aMessages[MSG_FILTER_OPEN_FILE] = 'Filter "$FILTER" cannot open file '.

    1360. 

  1360.                                        '"$FILE": $ERROR';

    1361. 

  1361. 

    1362. 

  1362.         // MSG_FILTER_FILE_ERROR is sent in an Alert message when a socket

    1363. 

  1363.         // filter gets an error message during reading a file

    1364. 

  1364.         // Parameters:

    1365. 

  1365.         //  FILTER  the filter name

    1366. 

  1366.         //  FILE    the file that could not be opened

    1367. 

  1367.         //  ERROR   the error message

    1368. 

  1368.         //  NLINES  the number of lines that were read successfully

    1369. 

  1369.     $aMessages[MSG_FILTER_FILE_ERROR] = 'Filter "$FILTER": read error on file '.

    1370. 

  1370.                                         '"$FILE" after $NLINES lines: $ERROR';

    1371. 

  1371. 

    1372. 

  1372.         // MSG_FILTER_READ_ERROR is sent in an Alert message when a socket

    1373. 

  1373.         // filter gets an error during reading from the socket

    1374. 

  1374.         // Parameters:

    1375. 

  1375.         //  FILTER  the filter name

    1376. 

  1376.         //  ERROR   the error message

    1377. 

  1377.     $aMessages[MSG_FILTER_READ_ERROR] = 'Filter "$FILTER" failed: read error: '.

    1378. 

  1378.                                         '$ERROR';

    1379. 

  1379. 

    1380. 

  1380.         // MSG_FILTER_NOT_OK is sent in an Alert message when a socket

    1381. 

  1381.         // filter fails to return the agreed __OK__ indicator

    1382. 

  1382.         // Parameters:

    1383. 

  1383.         //  FILTER  the filter name

    1384. 

  1384.         //  DATA    the data returned from the filter

    1385. 

  1385.     $aMessages[MSG_FILTER_NOT_OK] = 'Filter "$FILTER" failed (missing '.

    1386. 

  1386.                                     '__OK__ line): $DATA';

    1387. 

  1387. 

    1388. 

  1388.         // MSG_FILTER_UNK is sent in an Alert message

    1389. 

  1389.         // when an unknown filter is specified by a form

    1390. 

  1390.         // Parameters:

    1391. 

  1391.         //  FILTER  the filter name

    1392. 

  1392.     $aMessages[MSG_FILTER_UNK] = 'Unknown filter "$FILTER"';

    1393. 

  1393. 

    1394. 

  1394.         // MSG_FILTER_CHDIR is sent in an Alert message

    1395. 

  1395.         // when FormMail cannot change to the filter's directory

    1396. 

  1396.         // Parameters:

    1397. 

  1397.         //  FILTER  the filter name

    1398. 

  1398.         //  DIR     the directory name

    1399. 

  1399.         //  ERROR   an error message from the system

    1400. 

  1400.     $aMessages[MSG_FILTER_CHDIR] = 'Cannot chdir to "$DIR" to run filter '.

    1401. 

  1401.                                    '"$FILTER": $ERROR';

    1402. 

  1402. 

    1403. 

  1403.         // MSG_FILTER_NOTFOUND is sent in an Alert message

    1404. 

  1404.         // when FormMail cannot execute the filter

    1405. 

  1405.         // Parameters:

    1406. 

  1406.         //  FILTER  the filter name

    1407. 

  1407.         //  CMD     the command line being executed

    1408. 

  1408.         //  ERROR   an error message from the system

    1409. 

  1409.     $aMessages[MSG_FILTER_NOTFOUND] = 'Cannot execute filter "$FILTER" with '.

    1410. 

  1410.                                       'command "$CMD": $ERROR';

    1411. 

  1411. 

    1412. 

  1412.         // MSG_FILTER_ERROR is sent in an Alert message

    1413. 

  1413.         // when a filter returns a non-zero status

    1414. 

  1414.         // Parameters:

    1415. 

  1415.         //  FILTER  the filter name

    1416. 

  1416.         //  ERROR   an error message from the system

    1417. 

  1417.         //  STATUS  the status return from the command

    1418. 

  1418.     $aMessages[MSG_FILTER_ERROR] = 'Filter "$FILTER" failed (status $STATUS): '.

    1419. 

  1419.                                    '$ERROR';

    1420. 

  1420. 

    1421. 

  1421.         // MSG_SPARE is a spare message

    1422. 

  1422.     $aMessages[MSG_SPARE] = '';

    1423. 

  1423. 

    1424. 

  1424.         // MSG_TEMPLATE_ERRORS is sent as part of an Alert message

    1425. 

  1425.         // when a template has generated some errors.  The message

    1426. 

  1426.         // should end with a new line and the actual errors are

    1427. 

  1427.         // output after it.

    1428. 

  1428.         // Parameters:

    1429. 

  1429.         //  NAME    the template name

    1430. 

  1430.     $aMessages[MSG_TEMPLATE_ERRORS] = 'Template "$NAME" caused the '.

    1431. 

  1431.                                       'following errors $MNUM:\n';

    1432. 

  1432. 

    1433. 

  1433.         // MSG_TEMPLATE_FAILED is sent in an Alert message

    1434. 

  1434.         // when processing a template has failed.

    1435. 

  1435.         // Parameters:

    1436. 

  1436.         //  NAME    the template name

    1437. 

  1437.     $aMessages[MSG_TEMPLATE_FAILED] = 'Failed to process template "$NAME"';

    1438. 

  1438. 

    1439. 

  1439.         // MSG_MIME_PREAMBLE is sent in the preamble of MIME emails

    1440. 

  1440.         // Parameters: none

    1441. 

  1441.     $aMessages[MSG_MIME_PREAMBLE] = '(Your mail reader should not show this '.

    1442. 

  1442.                                     'text.\nIf it does you may need to '.

    1443. 

  1443.                                     'upgrade to more modern software.)';

    1444. 

  1444. 

    1445. 

  1445.         // MSG_MIME_HTML is sent in the preamble of HTML emails

    1446. 

  1446.         // Parameters:

    1447. 

  1447.         //  NAME    the template name

    1448. 

  1448.     $aMessages[MSG_MIME_HTML] = 'This message has been generated by FormMail '.

    1449. 

  1449.                                 'using an HTML template\ncalled "$NAME". The '.

    1450. 

  1450.                                 'raw text of the form results\nhas been '.

    1451. 

  1451.                                 'included below, but your mail reader should '.

    1452. 

  1452.                                 'display the HTML\nversion only (unless it\'s '.

    1453. 

  1453.                                 'not capable of doing so).';

    1454. 

  1454. 

    1455. 

  1455.         // MSG_FILE_OPEN_ERROR is sent in an Alert message when FormMail

    1456. 

  1456.         // cannot open a file

    1457. 

  1457.         // Parameters:

    1458. 

  1458.         //  NAME    the file name

    1459. 

  1459.         //  TYPE    the type of file

    1460. 

  1460.         //  ERROR   the system error message

    1461. 

  1461.     $aMessages[MSG_FILE_OPEN_ERROR] = 'Failed to open $TYPE file "$NAME": $ERROR';

    1462. 

  1462. 

    1463. 

  1463.         // MSG_ATTACH_DATA is sent in an Alert message when the file

    1464. 

  1464.         // attachment through 'data' has gone wrong.

    1465. 

  1465.         // Parameters: none

    1466. 

  1466.     $aMessages[MSG_ATTACH_DATA] = 'Internal error: AttachFile requires '.

    1467. 

  1467.                                   '"tmp_name" or "data"';

    1468. 

  1468. 

    1469. 

  1469.         // MSG_PHP_HTML_TEMPLATES is sent in an Alert message when an

    1470. 

  1470.         // HTML template is used but the PHP version is too old.

    1471. 

  1471.         // Parameters:

    1472. 

  1472.         //  $PHPVERS    the current PHP version

    1473. 

  1473.     $aMessages[MSG_PHP_HTML_TEMPLATES] = 'HTMLTemplate option is only supported '.

    1474. 

  1474.                                      'with PHP version 4.0.5 or above.  Your '.

    1475. 

  1475.                                      'server is running version $PHPVERS.';

    1476. 

  1476. 

    1477. 

  1477.         // MSG_PHP_FILE_UPLOADS is sent in an Alert message when

    1478. 

  1478.         // file upload is used but the PHP version is too old.

    1479. 

  1479.         // Parameters:

    1480. 

  1480.         //  $PHPVERS    the current PHP version

    1481. 

  1481.     $aMessages[MSG_PHP_FILE_UPLOADS] = 'For security reasons, file upload is only '.

    1482. 

  1482.                                    'allowed with PHP version 4.0.3 or above. '.

    1483. 

  1483.                                    'Your server is running version $PHPVERS.';

    1484. 

  1484. 

    1485. 

  1485.         // MSG_FILE_UPLOAD is sent in an Alert message when

    1486. 

  1486.         // file upload is attempted but FormMail is not configured to allow

    1487. 

  1487.         // it

    1488. 

  1488.         // Parameters: none

    1489. 

  1489.     $aMessages[MSG_FILE_UPLOAD] = 'File upload attempt ignored';

    1490. 

  1490. 

    1491. 

  1491.         // MSG_FILE_UPLOAD_ATTACK is sent in an Alert message when

    1492. 

  1492.         // possible file upload attack is detected

    1493. 

  1493.         // Parameters:

    1494. 

  1494.         //  NAME    file name

    1495. 

  1495.         //  TEMP    temporary file name

    1496. 

  1496.         //  FLD     name of the file upload field

    1497. 

  1497.     $aMessages[MSG_FILE_UPLOAD_ATTACK] = 'Possible file upload attack '.

    1498. 

  1498.                                          'detected: field="$FLD", name="$NAME" '.

    1499. 

  1499.                                          'temp name="$TEMP"';

    1500. 

  1500. 

    1501. 

  1501.         // MSG_PHP_PLAIN_TEMPLATES is sent in an Alert message when a

    1502. 

  1502.         // Plain template is used but the PHP version is too old.

    1503. 

  1503.         // Parameters:

    1504. 

  1504.         //  $PHPVERS    the current PHP version

    1505. 

  1505.     $aMessages[MSG_PHP_PLAIN_TEMPLATES] = 'PlainTemplate option is only supported '.

    1506. 

  1506.                                      'with PHP version 4.0.5 or above.  Your '.

    1507. 

  1507.                                      'server is running version $PHPVERS.';

    1508. 

  1508. 

    1509. 

  1509.         // MSG_ATTACH_NAME is sent in an Alert message when a

    1510. 

  1510.         // the form uses the Attach feature without specifying a file name

    1511. 

  1511.         // Parameters: none

    1512. 

  1512.     $aMessages[MSG_ATTACH_NAME] = 'filter_options: Attach must contain a name '.

    1513. 

  1513.                                   '(e.g. Attach=data.txt)';

    1514. 

  1514. 

    1515. 

  1515.         // MSG_PHP_BCC is sent in an Alert message when a

    1516. 

  1516.         // the form uses the BCC feature and the PHP version may not support it

    1517. 

  1517.         // Parameters:

    1518. 

  1518.         //  $PHPVERS    the current PHP version

    1519. 

  1519.     $aMessages[MSG_PHP_BCC] = 'Warning: BCC is probably not supported on your '.

    1520. 

  1520.                               'PHP version ($PHPVERS)';

    1521. 

  1521. 

    1522. 

  1522.         // MSG_CSVCOLUMNS is sent in an Alert message when a csvcolumns field

    1523. 

  1523.         // is not correct

    1524. 

  1524.         // Parameters:

    1525. 

  1525.         //  $VALUE  the csvcolumns field value

    1526. 

  1526.     $aMessages[MSG_CSVCOLUMNS] = 'The "csvcolumns" setting is not '.

    1527. 

  1527.                                  'valid: "$VALUE"';

    1528. 

  1528. 

    1529. 

  1529.         // MSG_CSVFILE is sent in an Alert message when a csvfile field

    1530. 

  1530.         // is not correct

    1531. 

  1531.         // Parameters:

    1532. 

  1532.         //  $VALUE  the csvfile field value

    1533. 

  1533.     $aMessages[MSG_CSVFILE] = 'The "csvfile" setting is not valid: "$VALUE"';

    1534. 

  1534. 

    1535. 

  1535.         // MSG_TARG_EMAIL_PAT_START is sent in an Alert message when a

    1536. 

  1536.         // $TARGET_EMAIL pattern is insecure because of a missing '^'

    1537. 

  1537.         // at the beginning

    1538. 

  1538.         // Parameters:

    1539. 

  1539.         //  $PAT    the pattern

    1540. 

  1540.     $aMessages[MSG_TARG_EMAIL_PAT_START] = 'Warning: Your TARGET_EMAIL pattern '.

    1541. 

  1541.                                            '"$PAT" is missing a ^ at the '.

    1542. 

  1542.                                            'beginning.';

    1543. 

  1543. 

    1544. 

  1544.         // MSG_TARG_EMAIL_PAT_END is sent in an Alert message when a

    1545. 

  1545.         // $TARGET_EMAIL pattern is insecure because of a missing '$'

    1546. 

  1546.         // at the end

    1547. 

  1547.         // Parameters:

    1548. 

  1548.         //  $PAT    the pattern

    1549. 

  1549.     $aMessages[MSG_TARG_EMAIL_PAT_END] = 'Warning: Your TARGET_EMAIL pattern '.

    1550. 

  1550.                                          '"$PAT" is missing a $ at the end.';

    1551. 

  1551. 

    1552. 

  1552.         // MSG_CONFIG_WARN is sent in an Alert message when the FormMail

    1553. 

  1553.         // configuration may have some problems.  The messages are

    1554. 

  1554.         // passed on separate lines, so the line terminations below

    1555. 

  1555.         // are important.

    1556. 

  1556.         // Parameters:

    1557. 

  1557.         //  $MESGS  lines of messages

    1558. 

  1558.     $aMessages[MSG_CONFIG_WARN] = 'The following potential problems were found '.

    1559. 

  1559.                                   'in your configuration:\n$MESGS\n\n'.

    1560. 

  1560.                                   'These are not necessarily errors, but you '.

    1561. 

  1561.                                   'should review the documentation\n'.

    1562. 

  1562.                                   'inside formmail.php.  If you are sure your '.

    1563. 

  1563.                                   'configuration is correct\n'.

    1564. 

  1564.                                   'you can disable the above messages by '.

    1565. 

  1565.                                   'changing the CONFIG_CHECK settings.';

    1566. 

  1566. 

    1567. 

  1567.         // MSG_PHP_AUTORESP is sent in an Alert message when the PHP version

    1568. 

  1568.         // does not support autoresponding

    1569. 

  1569.         // Parameters:

    1570. 

  1570.         //  $PHPVERS    current PHP version

    1571. 

  1571.     $aMessages[MSG_PHP_AUTORESP] = 'Autorespond is only supported with PHP '.

    1572. 

  1572.                                    'version 4.0.5 or above.  Your server is '.

    1573. 

  1573.                                    'running version $PHPVERS.';

    1574. 

  1574. 

    1575. 

  1575.         // MSG_ALERT is the test alert message (formmail.php?testalert=1)

    1576. 

  1576.         // Parameters:

    1577. 

  1577.         //  $LANG               the language ID

    1578. 

  1578.         //  $PHPVERS            PHP version

    1579. 

  1579.         //  $FM_VERS            FormMail version

    1580. 

  1580.         //  $SERVER             server type

    1581. 

  1581.         //  $DOCUMENT_ROOT      PHP's DOCUMENT_ROOT value

    1582. 

  1582.         //  $SCRIPT_FILENAME    PHP's SCRIPT_FILENAME value

    1583. 

  1583.         //  $PATH_TRANSLATED    PHP's PATH_TRANSLATED value

    1584. 

  1584.         //  $REAL_DOCUMENT_ROOT the REAL_DOCUMENT_ROOT value

    1585. 

  1585.     $aMessages[MSG_ALERT] = 'This is a test alert message $MNUM\n'.

    1586. 

  1586.                             'Loaded language is $LANG\n'.

    1587. 

  1587.                             'PHP version is $PHPVERS\n'.

    1588. 

  1588.                             'FormMail version is $FM_VERS\n'.

    1589. 

  1589.                             'Server type: $SERVER\n'.

    1590. 

  1590.                             '\n'.

    1591. 

  1591.                             'DOCUMENT_ROOT: $DOCUMENT_ROOT\n'.

    1592. 

  1592.                             'SCRIPT_FILENAME: $SCRIPT_FILENAME\n'.

    1593. 

  1593.                             'PATH_TRANSLATED: $PATH_TRANSLATED\n'.

    1594. 

  1594.                             'REAL_DOCUMENT_ROOT: $REAL_DOCUMENT_ROOT';

    1595. 

  1595. 

    1596. 

  1596.         // MSG_NO_DEF_ALERT is displayed if you use the testalert feature

    1597. 

  1597.         // and no DEF_ALERT setting has been provided.

    1598. 

  1598.         // Parameters: none

    1599. 

  1599.     $aMessages[MSG_NO_DEF_ALERT] = 'No DEF_ALERT value has been set.';

    1600. 

  1600. 

    1601. 

  1601.         // MSG_TEST_SENT is displayed if when use the testalert feature

    1602. 

  1602.         // Parameters: none

    1603. 

  1603.     $aMessages[MSG_TEST_SENT] = 'Test message sent.  Check your email.';

    1604. 

  1604. 

    1605. 

  1605.         // MSG_TEST_FAILED is displayed if when use the testalert feature

    1606. 

  1606.         // and the mail sending fails.

    1607. 

  1607.         // Parameters: none

    1608. 

  1608.     $aMessages[MSG_TEST_FAILED] = 'FAILED to send alert message.  Check your '.

    1609. 

  1609.                                   'server error logs.';

    1610. 

  1610. 

    1611. 

  1611.         // MSG_NO_DATA_PAGE is the page that's displayed if the user

    1612. 

  1612.         // just opens the URL to FormMail directly.

    1613. 

  1613.         // Parameters: none

    1614. 

  1614.     $aMessages[MSG_NO_DATA_PAGE] =  'This URL is a Form submission program.\n'.

    1615. 

  1615.                                     'It appears the form is not working '.

    1616. 

  1616.                                     'correctly as there was no data found.\n'.

    1617. 

  1617.                                     'You\'re not supposed to browse to this '.

    1618. 

  1618.                                     'URL; it should be accessed from a form.';

    1619. 

  1619. 

    1620. 

  1620.         // MSG_REQD_ERROR is displayed to the user as a default error

    1621. 

  1621.         // message when they haven't supplied some required fields

    1622. 

  1622.         // Parameters: none

    1623. 

  1623.     $aMessages[MSG_REQD_ERROR] = 'The form required some values that you '.

    1624. 

  1624.                                  'did not seem to provide.';

    1625. 

  1625. 

    1626. 

  1626.         // MSG_COND_ERROR is displayed to the user as a default error

    1627. 

  1627.         // message when some form conditions have failed

    1628. 

  1628.         // Parameters: none

    1629. 

  1629.     $aMessages[MSG_COND_ERROR] = 'Some of the values you provided are not valid.';

    1630. 

  1630. 

    1631. 

  1631.         // MSG_CRM_FAILURE is displayed to the user when submission

    1632. 

  1632.         // to the CRM has failed.

    1633. 

  1633.         // Parameters:

    1634. 

  1634.         //      $URL    the URL that was used

    1635. 

  1635.         //      $DATA   data returned from the CRM

    1636. 

  1636.     $aMessages[MSG_CRM_FAILURE] = 'The form submission did not succeed due to '.

    1637. 

  1637.                                   'a CRM failure. URL was \'$URL\'. '.

    1638. 

  1638.                                   'Returned CRM data:\n$DATA';

    1639. 

  1639. 

    1640. 

  1640.         // MSG_FOPTION_WARN is sent in an Alert message when the form

    1641. 

  1641.         // uses the superseded SendMailFOption feature

    1642. 

  1642.         // Parameters:

    1643. 

  1643.         //  $LINE   line number for SENDMAIL_F_OPTION

    1644. 

  1644.     $aMessages[MSG_FOPTION_WARN] = 'Warning: You\'ve used SendMailFOption in '.

    1645. 

  1645.                                    '"mail_options" in your form. This has been '.

    1646. 

  1646.                                    'superseded with a configuration setting '.

    1647. 

  1647.                                    'inside formmail.php.  Please update your '.

    1648. 

  1648.                                    'formmail.php configuration (look for '.

    1649. 

  1649.                                    'SENDMAIL_F_OPTION on line $LINE) and set '.

    1650. 

  1650.                                    'it to "true", then remove SendMailFOption '.

    1651. 

  1651.                                    'from your form(s).';

    1652. 

  1652. 

    1653. 

  1653.         // MSG_NO_ACTIONS is sent in an Alert message when there is no

    1654. 

  1654.         // action to perform or email address to send to

    1655. 

  1655.         // Parameters: none

    1656. 

  1656.     $aMessages[MSG_NO_ACTIONS] = 'The form has an internal error - no actions '.

    1657. 

  1657.                                  'or recipients were specified.';

    1658. 

  1658. 

    1659. 

  1659.         // MSG_NO_RECIP is sent in an Alert message when there are no

    1660. 

  1660.         // valid recipients to send to

    1661. 

  1661.         // Parameters: none

    1662. 

  1662.     $aMessages[MSG_NO_RECIP] = 'The form has an internal error - no valid '.

    1663. 

  1663.                                'recipients were specified.';

    1664. 

  1664. 

    1665. 

  1665.         // MSG_INV_EMAIL is sent in an Alert message when there are errors

    1666. 

  1666.         // in the email addresses specified in the form

    1667. 

  1667.         // Parameters:

    1668. 

  1668.         //  $ERRORS     list of errors

    1669. 

  1669.     $aMessages[MSG_INV_EMAIL] = 'Invalid email addresses were specified '.

    1670. 

  1670.                                 'in the form $MNUM:\n$ERRORS';

    1671. 

  1671. 

    1672. 

  1672.         // MSG_FAILED_SEND is sent in an Alert message when the mail sending fails.

    1673. 

  1673.         // Parameters: none

    1674. 

  1674.     $aMessages[MSG_FAILED_SEND] = 'Failed to send email';

    1675. 

  1675. 

    1676. 

  1676.         // MSG_ARESP_EMAIL is sent in an Alert message when

    1677. 

  1677.         // no email address has been specified for an autoreponse

    1678. 

  1678.         // Parameters: none

    1679. 

  1679.     $aMessages[MSG_ARESP_EMAIL] = 'No "email" field was found. Autorespond '.

    1680. 

  1680.                                   'requires the submitter\'s email address.';

    1681. 

  1681. 

    1682. 

  1682.         // MSG_ARESP_SUBJ is the default subject for the auto response email

    1683. 

  1683.         // Parameters: none

    1684. 

  1684.     $aMessages[MSG_ARESP_SUBJ] = 'Your form submission';

    1685. 

  1685. 

    1686. 

  1686.         // MSG_LOG_NO_VERIMG is written to the auto respond log file

    1687. 

  1687.         // if no VerifyImgString session variable was found

    1688. 

  1688.         // Parameters: none

    1689. 

  1689.     $aMessages[MSG_LOG_NO_VERIMG] = 'No VerifyImgString or turing_string in session, '.

    1690. 

  1690.                                     'no reverse CAPTCHA, no reCaptcha';

    1691. 

  1691. 

    1692. 

  1692.         // MSG_ARESP_NO_AUTH is shown to the user

    1693. 

  1693.         // if no VerifyImgString session variable was found

    1694. 

  1694.         // Parameters: none

    1695. 

  1695.     $aMessages[MSG_ARESP_NO_AUTH] = 'Failed to obtain authorization to send '.

    1696. 

  1696.                                     'you email. This is probably a fault on '.

    1697. 

  1697.                                     'the server.';

    1698. 

  1698. 

    1699. 

  1699.         // MSG_LOG_NO_MATCH is written to the auto respond log file

    1700. 

  1700.         // if the user's entry did not match the image verification

    1701. 

  1701.         // Parameters: none

    1702. 

  1702.     $aMessages[MSG_LOG_NO_MATCH] = 'User did not match image';

    1703. 

  1703. 

    1704. 

  1704.         // MSG_LOG_RECAPTCHA is written to the auto respond log file

    1705. 

  1705.         // if the reCaptcha process fails

    1706. 

  1706.         // Parameters:

    1707. 

  1707.         //  ERR the reCaptcha error code

    1708. 

  1708.     $aMessages[MSG_LOG_RECAPTCHA] = 'reCaptcha process failed ($ERR)';

    1709. 

  1709. 

    1710. 

  1710.         // MSG_ARESP_NO_MATCH is shown to the user

    1711. 

  1711.         // if the user's entry did not match the image verification

    1712. 

  1712.         // Parameters: none

    1713. 

  1713.     $aMessages[MSG_ARESP_NO_MATCH] = 'Your entry did not match the image';

    1714. 

  1714. 

    1715. 

  1715.         // MSG_LOG_FAILED is written to the auto respond log file

    1716. 

  1716.         // if the autoresponding failed

    1717. 

  1717.         // Parameters: none

    1718. 

  1718.     $aMessages[MSG_LOG_FAILED] = 'Failed';

    1719. 

  1719. 

    1720. 

  1720.         // MSG_ARESP_FAILED is sent in an Alert message

    1721. 

  1721.         // if the autoresponding failed

    1722. 

  1722.         // Parameters: none

    1723. 

  1723.     $aMessages[MSG_ARESP_FAILED] = 'Autoresponder failed';

    1724. 

  1724. 

    1725. 

  1725.         // MSG_LOG_OK is written to the auto respond log file

    1726. 

  1726.         // if the autoresponding succeeded

    1727. 

  1727.         // Parameters: none

    1728. 

  1728.     $aMessages[MSG_LOG_OK] = 'OK';

    1729. 

  1729. 

    1730. 

  1730.         // MSG_THANKS_PAGE is the default page that's displayed if the

    1731. 

  1731.         // submission is successful

    1732. 

  1732.         // Parameters: none

    1733. 

  1733.     $aMessages[MSG_THANKS_PAGE] = 'Thanks!  We\'ve received your information '.

    1734. 

  1734.                                   'and, if it\'s appropriate, we\'ll be in '.

    1735. 

  1735.                                   'contact with you soon.';

    1736. 

  1736. 

    1737. 

  1737.         // MSG_LOAD_MODULE is sent in an alert message if a module

    1738. 

  1738.         // could not be loaded.

    1739. 

  1739.         // Parameters:

    1740. 

  1740.         //  $FILE    the file name

    1741. 

  1741.         //  $ERROR   the error message

    1742. 

  1742.     $aMessages[MSG_LOAD_MODULE] = 'Cannot load module from file \'$FILE\': $ERROR';

    1743. 

  1743. 

    1744. 

  1744.         // MSG_LOAD_FMCOMPUTE is sent in an alert message if the form

    1745. 

  1745.         // specifies at least one "fmcompute" field and the FMCompute

    1746. 

  1746.         // module cannot be loaded.

    1747. 

  1747.         // Parameters:

    1748. 

  1748.         //  $FILE    the file name

    1749. 

  1749.         //  $ERROR   the error message

    1750. 

  1750.     $aMessages[MSG_LOAD_FMCOMPUTE] = 'Cannot load FMCompute module from file '.

    1751. 

  1751.                                         '\'$FILE\': $ERROR';

    1752. 

  1752. 

    1753. 

  1753.         // MSG_REGISTER_MODULE is sent in an alert message if a module

    1754. 

  1754.         // could not register with FMCompute

    1755. 

  1755.         // Parameters:

    1756. 

  1756.         //  $NAME    the name of the module

    1757. 

  1757.         //  $ERROR   the error message

    1758. 

  1758.     $aMessages[MSG_REGISTER_MODULE] = 'Cannot register module $NAME with '.

    1759. 

  1759.                                         'FMCompute: $ERROR';

    1760. 

  1760. 

    1761. 

  1761. 

    1762. 

  1762.         // MSG_COMP_PARSE is sent in an alert message if a parse error

    1763. 

  1763.         // occurs in an fmcompute field

    1764. 

  1764.         // Parameters:

    1765. 

  1765.         //  $CODE    the code with an error

    1766. 

  1766.         //  $ERRORS  the error messages

    1767. 

  1767.     $aMessages[MSG_COMP_PARSE] = 'These parse errors occurred in the following '.

    1768. 

  1768.                                     'code:\n$ERRORS\n$CODE';

    1769. 

  1769. 

    1770. 

  1770.         // MSG_COMP_REG_DATA is sent in an alert message if FormMail cannot

    1771. 

  1771.         // register a data field with the FMCompute module

    1772. 

  1772.         // Parameters:

    1773. 

  1773.         //  $NAME    the field name

    1774. 

  1774.         //  $ERROR  the error message

    1775. 

  1775.     $aMessages[MSG_COMP_REG_DATA] = 'Failed to register data field \'$NAME\': '.

    1776. 

  1776.                                     '$ERROR';

    1777. 

  1777. 

    1778. 

  1778.         // MSG_COMP_ALERT is sent in an alert message if the FMCompute

    1779. 

  1779.         // module has generated some alert messages.

    1780. 

  1780.         // Parameters:

    1781. 

  1781.         //  $ALERTS  the alerts

    1782. 

  1782.     $aMessages[MSG_COMP_ALERT] = 'The following alert messages were reported '.

    1783. 

  1783.                                 'from the FMCompute module: $ALERTS';

    1784. 

  1784. 

    1785. 

  1785.         // MSG_COMP_DEBUG is sent in an alert message if the FMCompute

    1786. 

  1786.         // module has generated some debug messages.

    1787. 

  1787.         // Parameters:

    1788. 

  1788.         //  $DEBUG  the alerts

    1789. 

  1789.     $aMessages[MSG_COMP_DEBUG] = 'The following debug messages were reported '.

    1790. 

  1790.                                 'from the FMCompute module: $DEBUG';

    1791. 

  1791. 

    1792. 

  1792.         // MSG_COMP_EXEC is sent in an alert message if the FMCompute

    1793. 

  1793.         // module has generated some error messages during execution

    1794. 

  1794.         // Parameters:

    1795. 

  1795.         //  $ERRORS  the errors

    1796. 

  1796.     $aMessages[MSG_COMP_EXEC] = 'The following error messages were reported '.

    1797. 

  1797.                                 'from the FMCompute module: $ERRORS';

    1798. 

  1798. 

    1799. 

  1799.         // MSG_TEMPL_ALERT is sent in an alert message if Advanced Template

    1800. 

  1800.         // Processing has generated some alert messages.

    1801. 

  1801.         // Parameters:

    1802. 

  1802.         //  $ALERTS  the alerts

    1803. 

  1803.     $aMessages[MSG_TEMPL_ALERT] = 'The following alert messages were reported '.

    1804. 

  1804.                                 'from the Advanced Template Processor: $ALERTS';

    1805. 

  1805. 

    1806. 

  1806.         // MSG_TEMPL_DEBUG is sent in an alert message if Advanced Template

    1807. 

  1807.         // Processing has generated some debug messages.

    1808. 

  1808.         // Parameters:

    1809. 

  1809.         //  $DEBUG  the alerts

    1810. 

  1810.     $aMessages[MSG_TEMPL_DEBUG] = 'The following debug messages were reported '.

    1811. 

  1811.                                 'from the Advanced Template Processor: $DEBUG';

    1812. 

  1812. 

    1813. 

  1813.         // MSG_TEMPL_PROC is sent in an alert message if Advanced Template Processing

    1814. 

  1814.         // has generated some error messages during processing

    1815. 

  1815.         // Parameters:

    1816. 

  1816.         //  $ERRORS  the errors

    1817. 

  1817.     $aMessages[MSG_TEMPL_PROC] = 'The following error messages were reported '.

    1818. 

  1818.                                 'from the Advanced Template Processor: $ERRORS';

    1819. 

  1819. 

    1820. 

  1820.         // MSG_REG_FMCOMPUTE is sent in an Alert message when FormMail

    1821. 

  1821.         // cannot register an external function with FMCompute.

    1822. 

  1822.         // Parameters:

    1823. 

  1823.         //  FUNC    the function that could not be registered

    1824. 

  1824.         //  ERROR   the error message

    1825. 

  1825.     $aMessages[MSG_REG_FMCOMPUTE] = 'Cannot register function "$FUNC" with '.

    1826. 

  1826.                                     'FMCompute: $ERROR';

    1827. 

  1827. 

    1828. 

  1828. 

    1829. 

  1829.         // MSG_USER_ERRORS is shown as part of a user error when an FMCompute

    1830. 

  1830.         // has called the "UserError" function one or more times.

    1831. 

  1831.         // Parameters:

    1832. 

  1832.         //  NONE

    1833. 

  1833.     $aMessages[MSG_USER_ERRORS] = 'One or more errors occurred in your form submission';

    1834. 

  1834. 

    1835. 

  1835. 

    1836. 

  1836.         // MSG_CALL_PARAM_COUNT is sent in an alert when a call to a FormMail

    1837. 

  1837.         // function from FMCompute has the wrong number of parameters

    1838. 

  1838.         // Parameters:

    1839. 

  1839.         //  FUNC    the function name

    1840. 

  1840.         //  COUNT   the actual number of parameters passed

    1841. 

  1841.     $aMessages[MSG_CALL_PARAM_COUNT] = 'FMCompute called FormMail function '.

    1842. 

  1842.                                        '\'$FUNC\' with wrong number of '.

    1843. 

  1843.                                        'parameters: $COUNT';

    1844. 

  1844. 

    1845. 

  1845.         // MSG_CALL_UNK_FUNC is sent in an alert when FMCompute calls an

    1846. 

  1846.         // unknown FormMail function

    1847. 

  1847.         // Parameters:

    1848. 

  1848.         //  FUNC    the function name

    1849. 

  1849.     $aMessages[MSG_CALL_UNK_FUNC] = 'FMCompute called unknown FormMail function '.

    1850. 

  1850.                                        '\'$FUNC\'';

    1851. 

  1851. 

    1852. 

  1852.         // MSG_SAVE_FILE is sent in an alert when saving a file to

    1853. 

  1853.         // the server has failed

    1854. 

  1854.         // Parameters:

    1855. 

  1855.         //  FILE    the source file name (usually a temporary file name)

    1856. 

  1856.         //  DEST    the destination file name

    1857. 

  1857.         //  ERR     the error message

    1858. 

  1858.     $aMessages[MSG_SAVE_FILE] = 'Failed to save file \'$FILE\' to \'$DEST\': $ERR';

    1859. 

  1859. 

    1860. 

  1860.         // MSG_SAVE_FILE_EXISTS is sent as part of an alert when saving a file to

    1861. 

  1861.         // the repository ($FILE_REPOSITORY) has failed because the file

    1862. 

  1862.         // already exists and FILE_OVERWRITE is set to false.

    1863. 

  1863.         // Parameters:

    1864. 

  1864.         //  FILE    the destination file name

    1865. 

  1865.     $aMessages[MSG_SAVE_FILE_EXISTS] = 'Cannot save file to repository as this would '.

    1866. 

  1866.                                         'overwrite \'$FILE\' and you have '.

    1867. 

  1867.                                         'set FILE_OVERWRITE to false.';

    1868. 

  1868. 

    1869. 

  1869.         // MSG_EMPTY_ADDRESSES is sent as part of an alert when a number of empty

    1870. 

  1870.         // email addresses have been specified in recipients, cc, or bcc

    1871. 

  1871.         // *and* there are no valid addresses provided

    1872. 

  1872.         // in the list

    1873. 

  1873.         // Parameters:

    1874. 

  1874.         //  COUNT    the number of empty addresses

    1875. 

  1875.     $aMessages[MSG_EMPTY_ADDRESSES] = '$COUNT empty addresses';

    1876. 

  1876. 

    1877. 

  1877.         // MSG_CALL_INVALID_PARAM is sent in an alert when a call to a FormMail

    1878. 

  1878.         // function from FMCompute has an invalid parameter

    1879. 

  1879.         // Parameters:

    1880. 

  1880.         //  FUNC    the function name

    1881. 

  1881.         //  PARAM   the parameter number

    1882. 

  1882.         //  CORRECT information about correct values

    1883. 

  1883.     $aMessages[MSG_CALL_INVALID_PARAM] = 'FMCompute called FormMail function '.

    1884. 

  1884.                                        '\'$FUNC\' with an invalid parameter '.

    1885. 

  1885.                                        'number $PARAM. Correct values are: $CORRECT';

    1886. 

  1886. 

    1887. 

  1887.         // MSG_INI_PARSE_WARN is sent in an alert when the INI file

    1888. 

  1888.         // may have a syntax error and cannot be parsed.

    1889. 

  1889.         // Parameters:

    1890. 

  1890.         //  FILE    the file name

    1891. 

  1891.     $aMessages[MSG_INI_PARSE_WARN] = 'Warning: your INI file \'$FILE\' appears '.

    1892. 

  1892.                                         'to be empty.  This may indicate a syntax error.';

    1893. 

  1893. 

    1894. 

  1894.         // MSG_INI_PARSE_ERROR is shown as an error message when the INI file

    1895. 

  1895.         // has a syntax error and cannot be parsed.

    1896. 

  1896.         // Parameters:

    1897. 

  1897.         //  FILE    the file name

    1898. 

  1898.     $aMessages[MSG_INI_PARSE_ERROR] = 'The FormMail INI file \'$FILE\' has a syntax error';

    1899. 

  1899. 

    1900. 

  1900.         // MSG_CHMOD is sent in an alert when changing the protection

    1901. 

  1901.         // mode of a file to has failed

    1902. 

  1902.         // Parameters:

    1903. 

  1903.         //  FILE    the file name

    1904. 

  1904.         //  MODE    the mode

    1905. 

  1905.         //  ERR     the error message

    1906. 

  1906.     $aMessages[MSG_CHMOD] = 'Failed to change protection mode of file \'$FILE\' '.

    1907. 

  1907.                             'to $MODE: $ERR';

    1908. 

  1908. 

    1909. 

  1909.         // MSG_VERIFY_MISSING is shown to the user image verification string

    1910. 

  1910.         // was not found

    1911. 

  1911.         // Parameters: none

    1912. 

  1912.     $aMessages[MSG_VERIFY_MISSING] = 'Image verification string missing. This'.

    1913. 

  1913.                                      ' is probably a fault on the server.';

    1914. 

  1914. 

    1915. 

  1915.         // MSG_VERIFY_MATCH is shown to the user

    1916. 

  1916.         // if the user's entry did not match the image verification for the

    1917. 

  1917.         // imgverify option

    1918. 

  1918.         // Parameters: none

    1919. 

  1919.     $aMessages[MSG_VERIFY_MATCH] = 'Your entry did not match the image';

    1920. 

  1920. 

    1921. 

  1921.         // MSG_RECAPTCHA_MATCH is shown to the user

    1922. 

  1922.         // if using the reCaptcha system and there was an error

    1923. 

  1923.         // Parameters:

    1924. 

  1924.         //  ERR the error code from the reCaptcha API

    1925. 

  1925.     $aMessages[MSG_RECAPTCHA_MATCH] = 'reCaptcha verification failed ($ERR)';

    1926. 

  1926. 

    1927. 

  1927.         // MSG_FILE_NAMES_INVALID is sent in an Alert message when

    1928. 

  1928.         // a form's file_names setting has errors

    1929. 

  1929.         // Parameters: none

    1930. 

  1930.         // A list of errors is appended on separate lines

    1931. 

  1931.     $aMessages[MSG_FILE_NAMES_INVALID] = 'Some file_names specifications are invalid $MNUM:\n';

    1932. 

  1932. 

    1933. 

  1933.         // MSG_FILE_NAMES_NOT_FILE is sent in an Alert message when

    1934. 

  1934.         // a form's file_names setting refers to a file field that doesn't

    1935. 

  1935.         // exist

    1936. 

  1936.         // Parameters:

    1937. 

  1937.         //      NAME    the name of the file field that doesn't exist

    1938. 

  1938.     $aMessages[MSG_FILE_NAMES_NOT_FILE] = 'Your file_names specification has '.

    1939. 

  1939.                                           'an error. \'$NAME\' is not the name '.

    1940. 

  1940.                                           'of a file upload field\n';

    1941. 

  1941. 

    1942. 

  1942.         // MSG_NEXT_PLUS_GOOD is sent in an alert message if the form is

    1943. 

  1943.         // ambiguous and specifies both "next_form" and "good_url" or

    1944. 

  1944.         // "good_template"

    1945. 

  1945.         // Parameters:

    1946. 

  1946.         //  $WHICH  the "good_" field that was specified

    1947. 

  1947.     $aMessages[MSG_NEXT_PLUS_GOOD] = 'The form has specified both "next_form" '.

    1948. 

  1948.                                     'and "$WHICH" fields - the action to '.

    1949. 

  1949.                                     'to perform is ambiguous';

    1950. 

  1950. 

    1951. 

  1951.         // MSG_MULTIFORM is sent in an Alert message when a form tries

    1952. 

  1952.         // to use a multi-form template, but templates have not been configured in

    1953. 

  1953.         // formmail.php

    1954. 

  1954.         // Parameters: none

    1955. 

  1955.     $aMessages[MSG_MULTIFORM] = 'You must set either MULTIFORMDIR or MULTIFORMURL '.

    1956. 

  1956.                                 'in formmail.php before you can use '.

    1957. 

  1957.                                 'multi-page forms.';

    1958. 

  1958. 

    1959. 

  1959.         // MSG_MULTIFORM_FAILED is sent in an Alert message

    1960. 

  1960.         // when processing a multi-page form template has failed.

    1961. 

  1961.         // Parameters:

    1962. 

  1962.         //  NAME    the template name

    1963. 

  1963.     $aMessages[MSG_MULTIFORM_FAILED] = 'Failed to process multi-page form template "$NAME"';

    1964. 

  1964. 

    1965. 

  1965.         // MSG_NEED_THIS_FORM is sent in an Alert message

    1966. 

  1966.         // when a multi-page form does not specify the "this_form" field.

    1967. 

  1967.         // Parameters:

    1968. 

  1968.         //  none

    1969. 

  1969.     $aMessages[MSG_NEED_THIS_FORM] = 'Multi-page forms require "this_form" field';

    1970. 

  1970. 

    1971. 

  1971.         // MSG_NO_PHP_SELF is sent in an Alert message

    1972. 

  1972.         // when FormMail requires the "PHP_SELF" server variable and PHP is not

    1973. 

  1973.         // providing it.

    1974. 

  1974.         // Parameters:

    1975. 

  1975.         //  none

    1976. 

  1976.     $aMessages[MSG_NO_PHP_SELF] = 'PHP on the server is not providing "PHP_SELF"';

    1977. 

  1977. 

    1978. 

  1978.         // MSG_RETURN_URL_INVALID is sent in an Alert message

    1979. 

  1979.         // when "this_form" is not a valid return URL.  This occurs for

    1980. 

  1980.         // multi-page forms.

    1981. 

  1981.         // Parameters:

    1982. 

  1982.         //  URL     the invalid URL

    1983. 

  1983.     $aMessages[MSG_RETURN_URL_INVALID] = 'Return URL "$URL" is not valid';

    1984. 

  1984. 

    1985. 

  1985.         // MSG_GO_BACK is sent in an Alert message

    1986. 

  1986.         // when "multi_go_back" has been submitted but this isn't part of a

    1987. 

  1987.         // multi-page form.

    1988. 

  1988.         // Parameters:

    1989. 

  1989.         //  none

    1990. 

  1990.     $aMessages[MSG_GO_BACK] = 'Cannot "go back" if not in a multi-page form '.

    1991. 

  1991.                               'sequence or at the first page of the form '.

    1992. 

  1992.                               'sequence';

    1993. 

  1993. 

    1994. 

  1994.         // MSG_OPEN_URL is sent in an Alert message when a URL cannot

    1995. 

  1995.         // be opened.

    1996. 

  1996.         // Parameters:

    1997. 

  1997.         //  URL     the invalid URL

    1998. 

  1998.         //  ERROR   error message

    1999. 

  1999.     $aMessages[MSG_OPEN_URL] = 'Cannot open URL "$URL": $ERROR';

    2000. 

  2000. 

    2001. 

  2001.         // MSG_CANNOT_RETURN is sent in an Alert message when an invalid return

    2002. 

  2002.         // request is made in a multi-page form sequence.

    2003. 

  2003.         // Parameters:

    2004. 

  2004.         //  TO          the requested page index

    2005. 

  2005.         //  TOPINDEX    the top page index

    2006. 

  2006.     $aMessages[MSG_CANNOT_RETURN] = 'Cannot return to page $TO.  The top page '.

    2007. 

  2007.                                     'index is $TOPINDEX';

    2008. 

  2008. 

    2009. 

  2009.         // MSG_ATTACK_DETECTED is sent in an Alert message when an attack on

    2010. 

  2010.         // the server has been detected

    2011. 

  2011.         // Parameters:

    2012. 

  2012.         //  ATTACK      name or description of the attack

    2013. 

  2013.         //  INFO        more information about the attack

    2014. 

  2014.     $aMessages[MSG_ATTACK_DETECTED] = 'Server attack "$ATTACK" detected. '.

    2015. 

  2015.                                       'Your server is safe as FormMail is '.

    2016. 

  2016.                                       'invulnerable to this attack.  You can '.

    2017. 

  2017.                                       'disable these messages by setting '.

    2018. 

  2018.                                       'ALERT_ON_ATTACK_DETECTION to false '.

    2019. 

  2019.                                       'in FormMail\'s configuration section.'.

    2020. 

  2020.                                       '\nMore information:\n$INFO';

    2021. 

  2021. 

    2022. 

  2022.         // MSG_ATTACK_PAGE is the contents of the browser page displayed to the

    2023. 

  2023.         // user when an attack is detected

    2024. 

  2024.         // Parameters:

    2025. 

  2025.         //  SERVER      the name of the server (website)

    2026. 

  2026.         //  USERINFO    details of the error

    2027. 

  2027.     $aMessages[MSG_ATTACK_PAGE] = 'Your form submission has been rejected '.

    2028. 

  2028.                                   'as it appears to be an abuse of our server ('.

    2029. 

  2029.                                   '$SERVER).<br />'.

    2030. 

  2030.                                   'Our supplier of forms processing software has '.

    2031. 

  2031.                                   'provided <a href="http://www.tectite.com/serverabuse.php" '.

    2032. 

  2032.                                   ' target="_blank">more information about this error</a>.<br /><br />'.

    2033. 

  2033.                                   '$USERINFO';

    2034. 

  2034. 

    2035. 

  2035.         // MSG_ATTACK_MIME_INFO is the contents of the INFO parameter

    2036. 

  2036.         // to the MSG_ATTACK_DETECTED message for the MIME attack

    2037. 

  2037.         // Parameters:

    2038. 

  2038.         //  FLD     name of the field

    2039. 

  2039.         //  CONTENT the invalid content found in the field

    2040. 

  2040.     $aMessages[MSG_ATTACK_MIME_INFO] = 'The field "$FLD" contained invalid '.

    2041. 

  2041.                                        'content "$CONTENT"';

    2042. 

  2042. 

    2043. 

  2043.         // MSG_ATTACK_DUP_INFO is the contents of the INFO parameter

    2044. 

  2044.         // to the MSG_ATTACK_DETECTED message for the Duplicate Data attack

    2045. 

  2045.         // Parameters:

    2046. 

  2046.         //  FLD1     name of the first field

    2047. 

  2047.         //  FLD2     name of the second field

    2048. 

  2048.     $aMessages[MSG_ATTACK_DUP_INFO] = 'The fields "$FLD1" and "$FLD2" contained '.

    2049. 

  2049.                                       'duplicate data';

    2050. 

  2050. 

    2051. 

  2051.         // MSG_ATTACK_SPEC_INFO is the contents of the INFO parameter

    2052. 

  2052.         // to the MSG_ATTACK_DETECTED message for the Special Field attack

    2053. 

  2053.         // Parameters:

    2054. 

  2054.         //  FLD     name of the special field

    2055. 

  2055.     $aMessages[MSG_ATTACK_SPEC_INFO] = 'Special field "$FLD" contained an email address';

    2056. 

  2056. 

    2057. 

  2057.         // MSG_ATTACK_MANYURL_INFO is the contents of the INFO parameter

    2058. 

  2058.         // to the MSG_ATTACK_DETECTED message for the Many URLs attack

    2059. 

  2059.         // Parameters:

    2060. 

  2060.         //  FLD     name of the field

    2061. 

  2061.         //  NUM     number of URLs detected

    2062. 

  2062.     $aMessages[MSG_ATTACK_MANYURL_INFO] = 'Field "$FLD" contained $NUM URLs';

    2063. 

  2063. 

    2064. 

  2064.         // MSG_ATTACK_MANYFIELDS_INFO is the contents of the INFO parameter

    2065. 

  2065.         // to the MSG_ATTACK_DETECTED message for the Many Fields with URLs

    2066. 

  2066.         // attack

    2067. 

  2067.         // Parameters:

    2068. 

  2068.         //  NUM     number of fields detected with URLs

    2069. 

  2069.         //  FLDS    list of fields with URLs in them

    2070. 

  2070.     $aMessages[MSG_ATTACK_MANYFIELDS_INFO] = '$NUM fields contained URLs: $FLDS';

    2071. 

  2071. 

    2072. 

  2072.         // MSG_REV_CAP is an error regarding the setting of ATTACK_DETECTION_REVERSE_CAPTCHA

    2073. 

  2073.         // Parameters: none

    2074. 

  2074.     $aMessages[MSG_REV_CAP] = 'ATTACK_DETECTION_REVERSE_CAPTCHA is not set correctly, '.

    2075. 

  2075.                                 'and will be ignored. Please refer to the documentation '.

    2076. 

  2076.                                 'to make the correct setting.';

    2077. 

  2077. 

    2078. 

  2078.         // MSG_ATTACK_REV_CAP_INFO is the contents of the INFO parameter

    2079. 

  2079.         // to the MSG_ATTACK_DETECTED message for the Reverse Captcha attack

    2080. 

  2080.         // detection

    2081. 

  2081.         // Parameters:

    2082. 

  2082.         //  FLD     name of the field

    2083. 

  2083.         //  CONTENT the invalid content found in the field

    2084. 

  2084.     $aMessages[MSG_ATTACK_REV_CAP_INFO] = 'The field "$FLD" contained unexpected '.

    2085. 

  2085.                                        'content "$CONTENT".';

    2086. 

  2086. 

    2087. 

  2087.         // MSG_ATTACK_JUNK_INFO is the contents of the INFO parameter

    2088. 

  2088.         // to the MSG_ATTACK_DETECTED message for the JUNK attack

    2089. 

  2089.         // Parameters:

    2090. 

  2090.         //  FLD     name of the field

    2091. 

  2091.         //  JUNK    the junk that was found

    2092. 

  2092.     $aMessages[MSG_ATTACK_JUNK_INFO] = 'The field "$FLD" contained junk '.

    2093. 

  2093.                                        'data "$JUNK"';

    2094. 

  2094. 

    2095. 

  2095.         // MSG_ARESP_EMPTY is an alert message sent when

    2096. 

  2096.         // an autoresponse template or file is empty

    2097. 

  2097.         // Parameters:

    2098. 

  2098.         //  TYPE    the type of autoreponse requested

    2099. 

  2099.     $aMessages[MSG_ARESP_EMPTY] = 'The autoresponse is empty.  The form '.

    2100. 

  2100.                                     'requested $TYPE';

    2101. 

  2101. 

    2102. 

  2102.         // MSG_NEED_SCRATCH_PAD is an alert message when processing requires

    2103. 

  2103.         // SCRATCH_PAD configuration for file upload processing.  This occurs

    2104. 

  2104.         // when you upload files in pages of a multi page form sequence.

    2105. 

  2105.         // Parameters:

    2106. 

  2106.         //  none

    2107. 

  2107.     $aMessages[MSG_NEED_SCRATCH_PAD] = 'You need to set SCRATCH_PAD in the '.

    2108. 

  2108.                                         'configuration section to process '.

    2109. 

  2109.                                         'uploaded files.';

    2110. 

  2110. 

    2111. 

  2111.         // MSG_OPEN_SCRATCH_PAD is an alert message when the SCRATCH_PAD

    2112. 

  2112.         // directory cannot be opened for cleanup.

    2113. 

  2113.         // Parameters:

    2114. 

  2114.         //  DIR     name of the directory

    2115. 

  2115.         //  ERR     more error information

    2116. 

  2116.     $aMessages[MSG_OPEN_SCRATCH_PAD] = 'Cannot open SCRATCH_PAD directory '.

    2117. 

  2117.                                         '"$DIR".  Open failed: $ERR';

    2118. 

  2118. 

    2119. 

  2119.         // MSG_NO_NEXT_NUM_FILE is an alert message when a form tries to

    2120. 

  2120.         // use the %nextnum% derivation feature but you haven't

    2121. 

  2121.         // setup FormMail's configuration correctly.

    2122. 

  2122.         // Parameters:

    2123. 

  2123.         //  none

    2124. 

  2124.     $aMessages[MSG_NO_NEXT_NUM_FILE] = 'You cannot use the %nextnum% feature: '.

    2125. 

  2125.                                         'you have not configured NEXT_NUM_FILE';

    2126. 

  2126. 

    2127. 

  2127.         // MSG_NEXT_NUM_FILE is an alert message when a form tries to

    2128. 

  2128.         // use the %nextnum% derivation feature but the next number file cannot

    2129. 

  2129.         // be processed.

    2130. 

  2130.         // Parameters:

    2131. 

  2131.         //  FILE    name of the file

    2132. 

  2132.         //  ACT     action

    2133. 

  2133.         //  ERR     more error information

    2134. 

  2134.     $aMessages[MSG_NEXT_NUM_FILE] = 'Cannot $ACT next number file '.

    2135. 

  2135. 

    2136. 

  2136.                                             '\'$FILE\': $ERR';

    2137. 

  2137. 

    2138. 

  2138.         // MSG_MULTI_UPLOAD is an alert message when processing of uploaded

    2139. 

  2139.         // fails during a multi-page form sequence

    2140. 

  2140.         // Parameters:

    2141. 

  2141.         //  none

    2142. 

  2142.     $aMessages[MSG_MULTI_UPLOAD] = 'File upload processing failed during '.

    2143. 

  2143.                                     'multi-page form processing.';

    2144. 

  2144. 

    2145. 

  2145.         // MSG_URL_PARSE is an error message when a URL to be opened

    2146. 

  2146.         // cannot be parsed

    2147. 

  2147.         // Parameters:

    2148. 

  2148.         //  none

    2149. 

  2149.     $aMessages[MSG_URL_PARSE] = 'Failed to parse URL';

    2150. 

  2150. 

    2151. 

  2151.         // MSG_URL_SCHEME is an error message when a URL to be opened

    2152. 

  2152.         // has an unsupported "scheme" value

    2153. 

  2153.         // Parameters:

    2154. 

  2154.         //  SCHEME     the scheme that was seen

    2155. 

  2155.     $aMessages[MSG_URL_SCHEME] = 'Unsupported URL scheme "$SCHEME"';

    2156. 

  2156. 

    2157. 

  2157.         // MSG_SOCKET is an error message when opening a socket for a URL

    2158. 

  2158.         // fails

    2159. 

  2159.         // Parameters:

    2160. 

  2160.         //  ERRNO     the error code

    2161. 

  2161.         //  ERRSTR    the error string

    2162. 

  2162.         //  PHPERR    the value of $php_errormsg

    2163. 

  2163.     $aMessages[MSG_SOCKET] = 'Socket error $ERRNO: $ERRSTR: $PHPERR';

    2164. 

  2164. 

    2165. 

  2165.         // MSG_GETURL_OPEN is an error message when the web server reports

    2166. 

  2166.         // a failure on opening a URL

    2167. 

  2167.         // Parameters:

    2168. 

  2168.         //  STATUS     the HTTP status value (number + string)

    2169. 

  2169.     $aMessages[MSG_GETURL_OPEN] = 'Open URL failed: $STATUS';

    2170. 

  2170. 

    2171. 

  2171.         // MSG_RESOLVE is an error message when a host name cannot be

    2172. 

  2172.         // resolved to an IP address

    2173. 

  2173.         // Parameters:

    2174. 

  2174.         //  NAME    the host name that could not be resolved

    2175. 

  2175.     $aMessages[MSG_RESOLVE] = 'Cannot resolve host name "$NAME"';

    2176. 

  2176. 

    2177. 

  2177.         // MSG_FORM_OK is the page title for the default

    2178. 

  2178.         // "thank you" page

    2179. 

  2179.         // Parameters:

    2180. 

  2180.         //  none

    2181. 

  2181.     $aMessages[MSG_FORM_OK] = 'Form Submission Succeeded';

    2182. 

  2182. 

    2183. 

  2183.         // MSG_FORM_ERROR is the page title for default

    2184. 

  2184.         // error pages

    2185. 

  2185.         // Parameters:

    2186. 

  2186.         //  none

    2187. 

  2187.     $aMessages[MSG_FORM_ERROR] = 'Form Submission Error';

    2188. 

  2188. 

    2189. 

  2189.         // MSG_GET_DISALLOWED is the message shown when GET method is used

    2190. 

  2190.         // but has been disabled.

    2191. 

  2191.         // Parameters:

    2192. 

  2192.         //  none

    2193. 

  2193.     $aMessages[MSG_GET_DISALLOWED] = 'GET method has been disabled.  Forms must use '.

    2194. 

  2194.                                         'the POST method. Alternatively, reconfigure '.

    2195. 

  2195.                                         'FormMail to allow the GET method.';

    2196. 

  2196. 

    2197. 

  2197.         // MSG_FILE_UPLOAD_ERRn are the error messages corresponding to the

    2198. 

  2198.         // PHP file upload error code n.

    2199. 

  2199.         // Parameters:

    2200. 

  2200.         //  none

    2201. 

  2201.     $aMessages[MSG_FILE_UPLOAD_ERR1] = 'The uploaded file exceeds the upload_max_filesize directive in php.ini.';

    2202. 

  2202.     $aMessages[MSG_FILE_UPLOAD_ERR2] = 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the html form.';

    2203. 

  2203.     $aMessages[MSG_FILE_UPLOAD_ERR3] = 'The uploaded file was only partially uploaded.';

    2204. 

  2204.     $aMessages[MSG_FILE_UPLOAD_ERR4] = 'No file was uploaded.';

    2205. 

  2205.     $aMessages[MSG_FILE_UPLOAD_ERR6] = 'Missing a temporary folder.';

    2206. 

  2206.     $aMessages[MSG_FILE_UPLOAD_ERR7] = 'Failed to write file to disk.';

    2207. 

  2207.     $aMessages[MSG_FILE_UPLOAD_ERR8] = 'File upload stopped by extension.';

    2208. 

  2208. 

    2209. 

  2209.         // MSG_FILE_UPLOAD_ERR_UNK is displayed when an unknown error code

    2210. 

  2210.         // is provided by PHP for a file upload

    2211. 

  2211.         // Parameters:

    2212. 

  2212.         //  ERRNO   the error code

    2213. 

  2213.     $aMessages[MSG_FILE_UPLOAD_ERR_UNK] = 'Unknown file upload error code $ERRNO';

    2214. 

  2214. 

    2215. 

  2215.         // MSG_FILE_UPLOAD_SIZE is displayed when an uploaded file exceeds

    2216. 

  2216.         // the configured maximum size

    2217. 

  2217.         // Parameters:

    2218. 

  2218.         //  NAME   the uploaded file's name

    2219. 

  2219.         //  SIZE   the size of the uploaded file

    2220. 

  2220.         //  MAX    the maximum size that was exceeded

    2221. 

  2221.     $aMessages[MSG_FILE_UPLOAD_SIZE] = 'Uploaded file "$NAME" is too big ('.

    2222. 

  2222.                                         '$SIZE bytes). The maximum permitted '.

    2223. 

  2223.                                         'size is $MAX kilobytes.';

    2224. 

  2224. 

    2225. 

  2225.         // MSG_DER_FUNC_ERROR is sent in an Alert message when

    2226. 

  2226.         // a form uses a derive_fields function that's

    2227. 

  2227.         // formatted incorrectly

    2228. 

  2228.         // Parameters:

    2229. 

  2229.         //  $SPEC   the invalid value specification

    2230. 

  2230.         //  $MSG    a message describing the error or providing an example

    2231. 

  2231.     $aMessages[MSG_DER_FUNC_ERROR] = 'derive_fields: invalid function specification '.

    2232. 

  2232.                                      '"$SPEC": $MSG';

    2233. 

  2233. 

    2234. 

  2234.         // MSG_DER_FUNC_SIZE_FMT describes the right syntax for the "size" function

    2235. 

  2235.         // Parameters:

    2236. 

  2236.         //  none

    2237. 

  2237.     $aMessages[MSG_DER_FUNC_SIZE_FMT] = '"size" function requires this format: '.

    2238. 

  2238.                                     'size(file_field)';

    2239. 

  2239. 

    2240. 

  2240.         // MSG_DER_FUNC_IF_FMT describes the right syntax for the "if" function

    2241. 

  2241.         // Parameters:

    2242. 

  2242.         //  none

    2243. 

  2243.     $aMessages[MSG_DER_FUNC_IF_FMT] = '"if" function requires this format: '.

    2244. 

  2244.                                     'if(field;spec;spec)';

    2245. 

  2245. 

    2246. 

  2246.         // MSG_DER_FUNC_NEXTNUM_FMT describes the right syntax for the "nextnum" function

    2247. 

  2247.         // Parameters:

    2248. 

  2248.         //  none

    2249. 

  2249.     $aMessages[MSG_DER_FUNC_NEXTNUM_FMT] = '"nextnum" function requires this format: '.

    2250. 

  2250.                                     'nextnum(pad) or nextnum(pad;base).  pad and base '.

    2251. 

  2251.                                     'must be numbers. base must be 2 to 36 inclusive';

    2252. 

  2252. 

    2253. 

  2253.         // MSG_DER_FUNC_EXT_FMT describes the right syntax for the "ext" function

    2254. 

  2254.         // Parameters:

    2255. 

  2255.         //  none

    2256. 

  2256.     $aMessages[MSG_DER_FUNC_EXT_FMT] = '"ext" function requires this format: '.

    2257. 

  2257.                                     'ext(file_field)';

    2258. 

  2258. 

    2259. 

  2259.         // MSG_DER_FUNC1_FMT describes the right syntax for a function

    2260. 

  2260.         // requiring one parameter

    2261. 

  2261.         // Parameters:

    2262. 

  2262.         //  FUNC    name of the function

    2263. 

  2263.     $aMessages[MSG_DER_FUNC1_FMT] = '"$FUNC" function requires this format: '.

    2264. 

  2264.                                     '$FUNC(fieldname)';

    2265. 

  2265. 

    2266. 

  2266.         // MSG_USER_ATTACK_JUNK is a message shown to the user when a junk

    2267. 

  2267.         // attack has been detected

    2268. 

  2268.         // Parameters:

    2269. 

  2269.         //  INPUT   the data the user input

    2270. 

  2270.     $aMessages[MSG_USER_ATTACK_JUNK] = 'The following input looks like a junk attack '.

    2271. 

  2271.                                         'on our server.  Please avoid scientific '.

    2272. 

  2272.                                         'or technical terms with long sequences '.

    2273. 

  2273.                                         'of consonants or vowels: $INPUT';

    2274. 

  2274. 

    2275. 

  2275.         // MSG_USER_ATTACK_REV_CAP is a message shown to the user when a reverse

    2276. 

  2276.         // captcha attack has been detected

    2277. 

  2277.         // Parameters:

    2278. 

  2278.         //  none

    2279. 

  2279.     $aMessages[MSG_USER_ATTACK_REV_CAP] = 'Your input looks like an automated spambot '.

    2280. 

  2280.                                         'attacking our server.  Some automatic form '.

    2281. 

  2281.                                         'fillers can trigger this detection. Try '.

    2282. 

  2282.                                         'filling in our form manually. If you use the '.

    2283. 

  2283.                                         'back button to go back, make sure you '.

    2284. 

  2284.                                         'refresh the page before trying again.';

    2285. 

  2285. 

    2286. 

  2286.         // MSG_USER_ATTACK_DUP is a message shown to the user when a duplicate

    2287. 

  2287.         // data attack has been detected

    2288. 

  2288.         // Parameters:

    2289. 

  2289.         //  none

    2290. 

  2290.     $aMessages[MSG_USER_ATTACK_DUP] = 'You have input the same information in '.

    2291. 

  2291.                                         'several fields in the form. Please '.

    2292. 

  2292.                                         're-submit the form without duplication';

    2293. 

  2293. 

    2294. 

  2294.         // MSG_USER_ATTACK_MANY_URLS is a message shown to the user when a many urls

    2295. 

  2295.         // attack has been detected

    2296. 

  2296.         // Parameters:

    2297. 

  2297.         //  none

    2298. 

  2298.     $aMessages[MSG_USER_ATTACK_MANY_URLS] = 'Your input includes a number of URLs. '.

    2299. 

  2299.                                             'This server has been configured to reject '.

    2300. 

  2300.                                             'form submissions with too many URLs. '.

    2301. 

  2301.                                             'Please re-submit the form without URLs or '.

    2302. 

  2302.                                             'with fewer URLs.';

    2303. 

  2303. 

    2304. 

  2304.         // MSG_USER_ATTACK_MANY_URL_FIELDS is a message shown to the user when a many urls

    2305. 

  2305.         // attack has been detected

    2306. 

  2306.         // Parameters:

    2307. 

  2307.         //  none

    2308. 

  2308.     $aMessages[MSG_USER_ATTACK_MANY_URL_FIELDS] = $aMessages[MSG_USER_ATTACK_MANY_URLS];

    2309. 

  2309. 

    2310. 

  2310. }  // <A NAME="BuiltinMessages"> Jump to: <A HREF="#MessageNumbers">

    2311. 

  2311. 

    2312. 

  2312.     //

    2313. 

  2313.     // If the form submission was using the GET method, switch to the

    2314. 

  2314.     // GET vars instead of the POST vars

    2315. 

  2315.     //

    2316. 

  2316. if (isset($aServerVars["REQUEST_METHOD"]) && $aServerVars["REQUEST_METHOD"] === "GET")

    2317. 

  2317. {

    2318. 

  2318.     $bIsGetMethod = true;

    2319. 

  2319.     if ($ALLOW_GET_METHOD)

    2320. 

  2320.     {

    2321. 

  2321.         if ($bUseOldVars)

    2322. 

  2322.             $aFormVars = &$HTTP_GET_VARS;

    2323. 

  2323.         else

    2324. 

  2324.             $aFormVars = &$_GET;

    2325. 

  2325.     }

    2326. 

  2326.     elseif (($bUseOldVars && count($HTTP_GET_VARS) > 0) || (!$bUseOldVars && count($_GET) > 0))

    2327. 

  2327.         $bHasGetData = true;

    2328. 

  2328. }

    2329. 

  2329. 

    2330. 

  2330.     //

    2331. 

  2331.     // Load the default language, and then override with an optional language file.

    2332. 

  2332.     //

    2333. 

  2333. function LoadLanguage()

    2334. 

  2334. {

    2335. 

  2335.     LoadBuiltinLanguage();

    2336. 

  2336.     LoadLanguageFile();

    2337. 

  2337. }

    2338. 

  2338. 

    2339. 

  2339.     //

    2340. 

  2340.     // To return the value of a string or empty string if not set.

    2341. 

  2341.     //

    2342. 

  2342. function CheckString($ss)

    2343. 

  2343. {

    2344. 

  2344.     return (isset($ss) ? $ss : "");

    2345. 

  2345. }

    2346. 

  2346. 

    2347. 

  2347. $aGetMessageSubstituteErrors = array();

    2348. 

  2348. $aGetMessageSubstituteFound = array();

    2349. 

  2349. $bGetMessageSubstituteNoErrors = false;

    2350. 

  2350. 

    2351. 

  2351.     //

    2352. 

  2352.     // Worker function for GetMessage's preg_replace_callback calls.

    2353. 

  2353.     // Returns the value of the matched variable name.

    2354. 

  2354.     // Variables are searched for in the global $aGetMessageValues.

    2355. 

  2355.     // If no such variable exists, an empty string is returned and the

    2356. 

  2356.     // global variable $aGetMessageSubstituteErrors lists the missing names.

    2357. 

  2357.     //

    2358. 

  2358. function GetMessageSubstituteParam($a_matches)

    2359. 

  2359. {

    2360. 

  2360.     global  $aGetMessageValues,$aGetMessageSubstituteErrors;

    2361. 

  2361.     global  $aGetMessageSubstituteFound,$bGetMessageSubstituteNoErrors;

    2362. 

  2362. 

    2363. 

  2363.     $s_name = $a_matches[1];

    2364. 

  2364.     $aGetMessageSubstituteFound[] = $s_name;

    2365. 

  2365.     $s_value = "";

    2366. 

  2366.     if (isset($aGetMessageValues[$s_name]))

    2367. 

  2367.         $s_value = $aGetMessageValues[$s_name];

    2368. 

  2368.     elseif ($bGetMessageSubstituteNoErrors)

    2369. 

  2369.         $s_value = '$'.$s_name;

    2370. 

  2370.     else

    2371. 

  2371.         $aGetMessageSubstituteErrors[] = $s_name;

    2372. 

  2372.     return ($s_value);

    2373. 

  2373. }

    2374. 

  2374. 

    2375. 

  2375.     //

    2376. 

  2376.     // Returns message text from a message number, with optional parameters.

    2377. 

  2377.     //

    2378. 

  2378. function GetMessage($i_msg_num,$a_params = array(),

    2379. 

  2379.                         $b_show_mnum = true,$b_no_errors = false)

    2380. 

  2380. {

    2381. 

  2381.     global  $aMessages,$sLangID,$bShowMesgNumbers;

    2382. 

  2382. 

    2383. 

  2383.     if (!isset($aMessages[$i_msg_num]))

    2384. 

  2384.     {

    2385. 

  2385.         SendAlert("Unknown Message Number $i_msg_num was used",false,true);

    2386. 

  2386.         $s_text = "<UNKNOWN MESSAGE NUMBER>";

    2387. 

  2387.     }

    2388. 

  2388.     else

    2389. 

  2389.         $s_text = $aMessages[$i_msg_num];

    2390. 

  2390.     $s_mno = $bShowMesgNumbers ? "[M$i_msg_num]" : "";

    2391. 

  2391. 

    2392. 

  2392.     $s_orig_text = $s_text;

    2393. 

  2393.         //

    2394. 

  2394.         // substitute parameters; only works with PHP version 4.0.5 or later

    2395. 

  2395.         //

    2396. 

  2396.     if (strpos($s_text,'$') !== false)

    2397. 

  2397.     {

    2398. 

  2398.         global  $aGetMessageValues,$aGetMessageSubstituteErrors;

    2399. 

  2399.         global  $aGetMessageSubstituteFound,$bGetMessageSubstituteNoErrors;

    2400. 

  2400. 

    2401. 

  2401.         $aGetMessageSubstituteErrors = array();

    2402. 

  2402.         $aGetMessageSubstituteFound = array();

    2403. 

  2403.         $aGetMessageValues = HTMLEntitiesArray($a_params,true);

    2404. 

  2404.         $bGetMessageSubstituteNoErrors = $b_no_errors;

    2405. 

  2405.         $aGetMessageValues["MNUM"] = $s_mno;    // add the message number

    2406. 

  2406.             //

    2407. 

  2407.             // search for words in this form:

    2408. 

  2408.             //      $word

    2409. 

  2409.             // where word begins with an alphabetic character and

    2410. 

  2410.             // consists of alphanumeric and underscore

    2411. 

  2411.             //

    2412. 

  2412.         $s_text = preg_replace_callback('/\$([a-z][a-z0-9_]*)/i',

    2413. 

  2413.                                             'GetMessageSubstituteParam',$s_text);

    2414. 

  2414.         if (count($aGetMessageSubstituteErrors) > 0)

    2415. 

  2415.             SendAlert("Message Number $i_msg_num ('$s_orig_text') in language $sLangID ".

    2416. 

  2416.                         "specified the following unsupported parameters: ".

    2417. 

  2417.                         implode(',',$aGetMessageSubstituteErrors));

    2418. 

  2418.         if (!in_array("MNUM",$aGetMessageSubstituteFound))

    2419. 

  2419.                 //

    2420. 

  2420.                 // append the message number

    2421. 

  2421.                 //

    2422. 

  2422.             $s_text .= $b_show_mnum ? " $s_mno" : "";

    2423. 

  2423.     }

    2424. 

  2424.     else

    2425. 

  2425.             //

    2426. 

  2426.             // append the message number

    2427. 

  2427.             //

    2428. 

  2428.         $s_text .= $b_show_mnum ? " $s_mno" : "";

    2429. 

  2429.         //

    2430. 

  2430.         // replace '\n' sequences with new lines

    2431. 

  2431.         //

    2432. 

  2432.     return (str_replace('\n',"\n",$s_text));

    2433. 

  2433. }

    2434. 

  2434. 

    2435. 

  2435.     //

    2436. 

  2436.     // Check for old version of PHP - die if too old.

    2437. 

  2437.     //

    2438. 

  2438. function IsOldVersion(&$a_this_version)

    2439. 

  2439. {

    2440. 

  2440.     $a_modern = array(4,1,0);   // versions prior to this are "old" - "4.1.0"

    2441. 

  2441.     $s_req_string = "4.0.5";    // version 4.0.5 of PHP is required from

    2442. 

  2442.                                 // FormMail 5.00 onward (because we use

    2443. 

  2443.                                 // preg_replace_callback for all messages to

    2444. 

  2444.                                 // support languages other than English)

    2445. 

  2445.     $a_too_old = explode(".",$s_req_string);

    2446. 

  2446. 

    2447. 

  2447.     $i_cannot_use = ($a_too_old[0] * 10000) +

    2448. 

  2448.                     ($a_too_old[1] * 100) +

    2449. 

  2449.                     $a_too_old[2];

    2450. 

  2450. 

    2451. 

  2451.     $s_vers_string = phpversion();

    2452. 

  2452.     $a_this_version = explode(".",$s_vers_string);

    2453. 

  2453.     $i_this_num = ($a_this_version[0] * 10000) +

    2454. 

  2454.                     ($a_this_version[1] * 100) +

    2455. 

  2455.                     $a_this_version[2];

    2456. 

  2456. 

    2457. 

  2457.     if ($i_this_num <= $i_cannot_use)

    2458. 

  2458.         die(GetMessage(MSG_SCRIPT_VERSION,array("PHPREQ"=>$s_req_string,

    2459. 

  2459.                                                 "PHPVERS"=>$s_vers_string)));

    2460. 

  2460.     $i_modern_num = ($a_modern[0] * 10000) +

    2461. 

  2461.                     ($a_modern[1] * 100) +

    2462. 

  2462.                     $a_modern[2];

    2463. 

  2463.     return ($i_this_num < $i_modern_num);

    2464. 

  2464. }

    2465. 

  2465. 

    2466. 

  2466.     //

    2467. 

  2467.     // Check if the server is Windows

    2468. 

  2468.     //

    2469. 

  2469. function IsServerWindows()

    2470. 

  2470. {

    2471. 

  2471.     static  $bGotAnswer = false;

    2472. 

  2472.     static  $bAnswer;

    2473. 

  2473. 

    2474. 

  2474.     if (!$bGotAnswer)

    2475. 

  2475.     {

    2476. 

  2476.         if ((isset($_ENV["OS"]) && stristr($_ENV["OS"],"windows") !== false) ||

    2477. 

  2477.             (isset($_SERVER["PATH"]) && stristr($_SERVER["PATH"],"winnt") !== false) ||

    2478. 

  2478.             (isset($_SERVER["PATH"]) && stristr($_SERVER["PATH"],"windows") !== false) ||

    2479. 

  2479.             (isset($_SERVER["SystemRoot"]) && stristr($_SERVER["SystemRoot"],"winnt") !== false) ||

    2480. 

  2480.             (isset($_ENV["SystemRoot"]) && stristr($_ENV["SystemRoot"],"winnt") !== false) ||

    2481. 

  2481.             (isset($_SERVER["SystemRoot"]) && stristr($_SERVER["SystemRoot"],"windows") !== false) ||

    2482. 

  2482.             (isset($_ENV["SystemRoot"]) && stristr($_ENV["SystemRoot"],"windows") !== false) ||

    2483. 

  2483.             (isset($_SERVER["Path"]) && stristr($_SERVER["Path"],"windows") !== false))

    2484. 

  2484.             $bAnswer = true;

    2485. 

  2485.         else

    2486. 

  2486.             $bAnswer = false;

    2487. 

  2487.         $bGotAnswer = true;

    2488. 

  2488.     }

    2489. 

  2489.     return ($bAnswer);

    2490. 

  2490. }

    2491. 

  2491. 

    2492. 

  2492.     //

    2493. 

  2493.     // To return a temporary file name from $SCRATCH_PAD

    2494. 

  2494.     //

    2495. 

  2495. function GetScratchPadFile($s_prefix)

    2496. 

  2496. {

    2497. 

  2497.     global  $SCRATCH_PAD;

    2498. 

  2498. 

    2499. 

  2499.     switch (substr($SCRATCH_PAD,-1))

    2500. 

  2500.     {

    2501. 

  2501.     case '/':

    2502. 

  2502.     case '\\':

    2503. 

  2503.         $s_dir = substr($SCRATCH_PAD,0,-1);

    2504. 

  2504.         break;

    2505. 

  2505.     default:

    2506. 

  2506.         $s_dir = $SCRATCH_PAD;

    2507. 

  2507.         break;

    2508. 

  2508.     }

    2509. 

  2509.         //

    2510. 

  2510.         // Ideally, we could use tempnam. But,

    2511. 

  2511.         // tempnam is system dependent and might not use the

    2512. 

  2512.         // SCRATCH_PAD directory even if we tell it to.

    2513. 

  2513.         // So, we'll force the file into SCRATCH_PAD.

    2514. 

  2514.         //

    2515. 

  2515.         // Note that we do *not* create the file, even though tempnam

    2516. 

  2516.         // does create it in PHP version 4.0.3 and above. (The reason is

    2517. 

  2517.         // we can't guarantee a non-race condition anyway.)

    2518. 

  2518.         //

    2519. 

  2519.     do

    2520. 

  2520.     {

    2521. 

  2521.         $i_rand = mt_rand(0,16777215);  // 16777215 is FFFFFF in hex

    2522. 

  2522.         $s_name = $SCRATCH_PAD."/".$s_prefix.sprintf("%06X",$i_rand);

    2523. 

  2523.     }

    2524. 

  2524.     while (file_exists($s_name));

    2525. 

  2525.     return ($s_name);

    2526. 

  2526. }

    2527. 

  2527. 

    2528. 

  2528.     //

    2529. 

  2529.     // To return a temporary file name.

    2530. 

  2530.     //

    2531. 

  2531. function GetTempName($s_prefix)

    2532. 

  2532. {

    2533. 

  2533.     global  $SCRATCH_PAD;

    2534. 

  2534. 

    2535. 

  2535.     if (isset($SCRATCH_PAD) && !empty($SCRATCH_PAD))

    2536. 

  2536.         $s_name = GetScratchPadFile($s_prefix);

    2537. 

  2537. 

    2538. 

  2538.     else

    2539. 

  2539.         $s_name = tempnam("/tmp",$s_prefix);

    2540. 

  2540.     return ($s_name);

    2541. 

  2541. }

    2542. 

  2542. 

    2543. 

  2543.     //

    2544. 

  2544.     // To find a directory on the server for temporary files.

    2545. 

  2545.     //

    2546. 

  2546. function GetTempDir()

    2547. 

  2547. {

    2548. 

  2548.     $s_name = GetTempName("fm");

    2549. 

  2549.     if (file_exists($s_name))

    2550. 

  2550.         unlink($s_name);

    2551. 

  2551.     $s_dir = dirname($s_name);

    2552. 

  2552.     return ($s_dir);

    2553. 

  2553. }

    2554. 

  2554. 

    2555. 

  2555.     //

    2556. 

  2556.     // Returns true if the PHP version is at or later than the string specified

    2557. 

  2557.     // (can't use "version_compare" before 4.1.0).

    2558. 

  2558.     //

    2559. 

  2559. function IsPHPAtLeast($s_vers)

    2560. 

  2560. {

    2561. 

  2561.     global  $aPHPVERSION;

    2562. 

  2562. 

    2563. 

  2563.     $a_test_version = explode(".",$s_vers);

    2564. 

  2564.     if (count($a_test_version) < 3)

    2565. 

  2565.         return (false);

    2566. 

  2566.     return ($aPHPVERSION[0] > $a_test_version[0] ||

    2567. 

  2567.             ($aPHPVERSION[0] == $a_test_version[0] &&

    2568. 

  2568.                 ($aPHPVERSION[1] > $a_test_version[1] ||

    2569. 

  2569.                     $aPHPVERSION[1] == $a_test_version[1] &&

    2570. 

  2570.                         $aPHPVERSION[2] >= $a_test_version[2])));

    2571. 

  2571. }

    2572. 

  2572. 

    2573. 

  2573. define('DEBUG',false);      // for production

    2574. 

  2574. //define('DEBUG',true);         // for development and debugging

    2575. 

  2575. define('RFCLINELEN',76);      // recommend maximum line length from RFC 2822

    2576. 

  2576. 

    2577. 

  2577.     //

    2578. 

  2578.     // The user agent string to use when opening URLs

    2579. 

  2579.     //

    2580. 

  2580. $sUserAgent = "FormMail/$FM_VERS (from www.tectite.com)";

    2581. 

  2581. 

    2582. 

  2582. if (DEBUG)

    2583. 

  2583. {

    2584. 

  2584.     error_reporting(E_ALL);     // trap everything!

    2585. 

  2585.     if (IsPHPAtLeast("5.0.0"))

    2586. 

  2586.         ini_set("display_errors","stdout");

    2587. 

  2587.     else

    2588. 

  2588.         ini_set("display_errors","1");

    2589. 

  2589.     ini_set("display_startup_errors","1");

    2590. 

  2590.     assert_options(ASSERT_ACTIVE,true);

    2591. 

  2591.     assert_options(ASSERT_BAIL,true);

    2592. 

  2592.     LoadLanguage();

    2593. 

  2593. }

    2594. 

  2594. else

    2595. 

  2595. {

    2596. 

  2596.     $iOldLevel = error_reporting(E_ALL ^ E_WARNING);

    2597. 

  2597.     LoadLanguage();

    2598. 

  2598.         //

    2599. 

  2599.         // report everyting except warnings and notices

    2600. 

  2600.         //

    2601. 

  2601.     error_reporting(E_ALL ^ E_WARNING ^ E_NOTICE);

    2602. 

  2602. }

    2603. 

  2603. 

    2604. 

  2604. function SetRealDocumentRoot()

    2605. 

  2605. {

    2606. 

  2606.     global  $aServerVars,$REAL_DOCUMENT_ROOT;

    2607. 

  2607. 

    2608. 

  2608.     if (isset($aServerVars['SCRIPT_FILENAME']))

    2609. 

  2609.         $REAL_DOCUMENT_ROOT = $aServerVars['SCRIPT_FILENAME'];

    2610. 

  2610.     elseif (isset($aServerVars['PATH_TRANSLATED']))

    2611. 

  2611.         $REAL_DOCUMENT_ROOT = $aServerVars['PATH_TRANSLATED'];

    2612. 

  2612.     else

    2613. 

  2613.         $REAL_DOCUMENT_ROOT = "";

    2614. 

  2614.         //

    2615. 

  2615.         // look for 'www' or 'public_html' and strip back to that if found,

    2616. 

  2616.         // otherwise just get the directory name

    2617. 

  2617.         //

    2618. 

  2618.     if (($i_pos = strpos($REAL_DOCUMENT_ROOT,"/www/")) !== false)

    2619. 

  2619.         $REAL_DOCUMENT_ROOT = substr($REAL_DOCUMENT_ROOT,0,$i_pos+4);

    2620. 

  2620.     elseif (($i_pos = strpos($REAL_DOCUMENT_ROOT,"/public_html/")) !== false)

    2621. 

  2621.         $REAL_DOCUMENT_ROOT = substr($REAL_DOCUMENT_ROOT,0,$i_pos+12);

    2622. 

  2622.     elseif (!empty($REAL_DOCUMENT_ROOT))

    2623. 

  2623.         $REAL_DOCUMENT_ROOT = dirname($REAL_DOCUMENT_ROOT);

    2624. 

  2624.     elseif (isset($aServerVars['DOCUMENT_ROOT']) &&

    2625. 

  2625.             !empty($aServerVars['DOCUMENT_ROOT']))

    2626. 

  2626.         $REAL_DOCUMENT_ROOT = $aServerVars['DOCUMENT_ROOT'];

    2627. 

  2627. }

    2628. 

  2628. 

    2629. 

  2629.     //

    2630. 

  2630.     // Hook system: before initialization (but after configuration)

    2631. 

  2631.     //

    2632. 

  2632. if ($HOOK_DIR !== "")

    2633. 

  2633.     if (!@include("$HOOK_DIR/fmhookpreinit.inc.php"))

    2634. 

  2634. 		@include("$HOOK_DIR/fmhookpreinit.inc");

    2635. 

  2635. 

    2636. 

  2636. if (!empty($SESSION_NAME))

    2637. 

  2637.     session_name($SESSION_NAME);

    2638. 

  2638. 

    2639. 

  2639.     //

    2640. 

  2640.     // Session data access

    2641. 

  2641.     //

    2642. 

  2642. function    GetSession($s_name)

    2643. 

  2643. {

    2644. 

  2644.     global  $bUseOldVars,$HTTP_SESSION_VARS;

    2645. 

  2645. 

    2646. 

  2646.     if ($bUseOldVars)

    2647. 

  2647.         return (isset($HTTP_SESSION_VARS) ? $HTTP_SESSION_VARS[$s_name] : null);

    2648. 

  2648.     else

    2649. 

  2649.         return (isset($_SESSION) ? $_SESSION[$s_name] : null);

    2650. 

  2650. }

    2651. 

  2651. 

    2652. 

  2652.     //

    2653. 

  2653.     // Session data isset

    2654. 

  2654.     //

    2655. 

  2655. function    IsSetSession($s_name)

    2656. 

  2656. {

    2657. 

  2657.     global  $bUseOldVars,$HTTP_SESSION_VARS;

    2658. 

  2658. 

    2659. 

  2659.     if ($bUseOldVars)

    2660. 

  2660.         return (isset($HTTP_SESSION_VARS) && isset($HTTP_SESSION_VARS[$s_name]));

    2661. 

  2661.     else

    2662. 

  2662.         return (isset($_SESSION) && isset($_SESSION[$s_name]));

    2663. 

  2663. }

    2664. 

  2664. 

    2665. 

  2665.     //

    2666. 

  2666.     // Session data setting

    2667. 

  2667.     //

    2668. 

  2668. function    SetSession($s_name,$m_value)

    2669. 

  2669. {

    2670. 

  2670.     global  $bUseOldVars,$HTTP_SESSION_VARS;

    2671. 

  2671. 

    2672. 

  2672.     if ($bUseOldVars)

    2673. 

  2673.         $HTTP_SESSION_VARS[$s_name] = $m_value;

    2674. 

  2674.     else

    2675. 

  2675.         $_SESSION[$s_name] = $m_value;

    2676. 

  2676. }

    2677. 

  2677. 

    2678. 

  2678.     //

    2679. 

  2679. 

    2680. 

  2680.     // Session data un-setting

    2681. 

  2681.     //

    2682. 

  2682. function    UnsetSession($s_name)

    2683. 

  2683. {

    2684. 

  2684.     global  $bUseOldVars,$HTTP_SESSION_VARS;

    2685. 

  2685. 

    2686. 

  2686.     if ($bUseOldVars)

    2687. 

  2687.     {

    2688. 

  2688.         $HTTP_SESSION_VARS[$s_name] = null;

    2689. 

  2689.         unset($HTTP_SESSION_VARS[$s_name]);

    2690. 

  2690.     }

    2691. 

  2691.     else

    2692. 

  2692.     {

    2693. 

  2693.         $_SESSION[$s_name] = null;

    2694. 

  2694.         unset($_SESSION[$s_name]);

    2695. 

  2695.     }

    2696. 

  2696. }

    2697. 

  2697. 

    2698. 

  2698. function ZapSession()

    2699. 

  2699. {

    2700. 

  2700.     global  $aSessionVarNames;

    2701. 

  2701. 

    2702. 

  2702.     if (DESTROY_SESSION)

    2703. 

  2703.     {

    2704. 

  2704.         if (session_id() != '')

    2705. 

  2705.             session_destroy();

    2706. 

  2706.     }

    2707. 

  2707.     else

    2708. 

  2708.     {

    2709. 

  2709.         foreach ($aSessionVarNames as $s_var_name)

    2710. 

  2710.             UnsetSession($s_var_name);

    2711. 

  2711.     }

    2712. 

  2712. }

    2713. 

  2713. 

    2714. 

  2714. $bReverseCaptchaCompleted = false;      // records whether ATTACK_DETECTION_REVERSE_CAPTCHA has been completed successfully

    2715. 

  2715. session_start();

    2716. 

  2716. 

    2717. 

  2717.     //

    2718. 

  2718.     // This array lists the private variables used by FormMail.

    2719. 

  2719.     // We use the names here to cleanup the session when FormMail has

    2720. 

  2720.     // finished its processing.

    2721. 

  2721.     //

    2722. 

  2722. $aSessionVarNames = array("FormError","FormErrorInfo","FormErrorCode",

    2723. 

  2723.                         "FormErrorItems","FormData","FormIsUserError",

    2724. 

  2724.                         "FormAlerted","FormSavedFiles","FormIndex",

    2725. 

  2725.                         "FormList","FormKeep","VerifyImgString",

    2726. 

  2726.                         "turing_string");

    2727. 

  2727. 

    2728. 

  2728. UnsetSession("FormError");                  // start with no error

    2729. 

  2729. UnsetSession("FormErrorInfo");              // start with no error

    2730. 

  2730. UnsetSession("FormErrorCode");              // start with no error

    2731. 

  2731. UnsetSession("FormErrorItems");             // start with no error

    2732. 

  2732. UnsetSession("FormData");                   // start with no data

    2733. 

  2733. UnsetSession("FormIsUserError");            // start with no data

    2734. 

  2734. UnsetSession("FormAlerted");                // start with no data

    2735. 

  2735. 

    2736. 

  2736. //

    2737. 

  2737. // Note that HTTP_REFERER is easily spoofed, so there's no point in

    2738. 

  2738. // using it for security.

    2739. 

  2739. //

    2740. 

  2740. 

    2741. 

  2741.     //

    2742. 

  2742.     // SPECIAL_FIELDS is the list of fields that formmail.php looks for to

    2743. 

  2743.     // control its operation

    2744. 

  2744.     //

    2745. 

  2745. $SPECIAL_FIELDS = array(

    2746. 

  2746.         "email",        // email address of the person who filled in the form

    2747. 

  2747.         "realname",     // the real name of the person who filled in the form

    2748. 

  2748.         "recipients",   // comma-separated list of email addresses to which we'll send the results

    2749. 

  2749.         "cc",           // comma-separated list of email addresses to which we'll CC the results

    2750. 

  2750.         "bcc",          // comma-separated list of email addresses to which we'll BCC the results

    2751. 

  2751.         "replyto",      // comma-separated list of email addresses to whom replies should be sent

    2752. 

  2752.         "required",     // comma-separated list of fields that must be found in the input

    2753. 

  2753.         "conditions",   // complex condition tests

    2754. 

  2754.         "fmcompute",    // computations

    2755. 

  2755.         "fmmodules",    // list of modules required

    2756. 

  2756.         "fmmode",       // mode of operation

    2757. 

  2757.         "mail_options", // comma-separated list of options

    2758. 

  2758.         "good_url",     // URL to go to on success

    2759. 

  2759.         "good_template",// template file to display on success

    2760. 

  2760.         "bad_url",      // URL to go to on error

    2761. 

  2761.         "bad_template", // template file to display on error

    2762. 

  2762.         "template_list_sep", // separator when expanding lists in templates

    2763. 

  2763.         "this_form",    // the URL of the form (can be used by bad_url)

    2764. 

  2764.         "subject",      // subject for the email

    2765. 

  2765.         "env_report",   // comma-separated list of environment variables to report

    2766. 

  2766.         "filter",       // a supported filter to use

    2767. 

  2767.         "filter_options",// options for using the filter

    2768. 

  2768.         "filter_fields",// list of fields to filter (default is to filter all fields)

    2769. 

  2769.         "filter_files", // list of file fields to filter (default is to filter no file fields)

    2770. 

  2770.         "logfile",      // log file to write to

    2771. 

  2771.         "csvfile",      // file to write CSV records to

    2772. 

  2772.         "csvcolumns",   // columns to save in the csvfile

    2773. 

  2773.         "crm_url",      // URL for sending data to the CRM; note that the

    2774. 

  2774.                         // value must have a valid prefix specified in TARGET_URLS

    2775. 

  2775.         "crm_spec",     // CRM specification (field mapping)

    2776. 

  2776.         "crm_options",  // comma-separated list of options to control CRM processing

    2777. 

  2777.         "derive_fields", // a list of fields to derive from other fields

    2778. 

  2778.         "file_names",   // specifies names for files being uploaded

    2779. 

  2779.         "autorespond",  // specification for auto-responding

    2780. 

  2780.         "arverify",     // verification field to allow auto-responding

    2781. 

  2781.         "imgverify",    // verification field to allow submission

    2782. 

  2782.         "multi_start",  // set this field on the first page of a multi-page form sequence

    2783. 

  2783.         "multi_keep",   // set this field on the pages of a multi-page form sequence

    2784. 

  2784.                         // to the list of fields that should be kept when moving

    2785. 

  2785.                         // forward after going backwards

    2786. 

  2786.         "next_form",    // next form name or empty for last form

    2787. 

  2787.         "multi_go_back",// this field should be set when the user clicks the

    2788. 

  2788.                         // back button or link in a multi-page form sequence

    2789. 

  2789.         "alert_to",    // email address to send alerts (errors) to

    2790. 

  2790.             //

    2791. 

  2791.             // fields for reCaptcha implementation

    2792. 

  2792.             //

    2793. 

  2793.         "recaptcha_response_field",    // verification field to allow submission

    2794. 

  2794.         "recaptcha_challenge_field",   // challenge field

    2795. 

  2795.         );

    2796. 

  2796. 

    2797. 

  2797.     //

    2798. 

  2798.     // $SPECIAL_MULTI is the list of fields from $SPECIAL_FIELDS that can

    2799. 

  2799.     // have multiple values, for example:

    2800. 

  2800.     //      name="conditions1"

    2801. 

  2801.     //      name="conditions2"

    2802. 

  2802.     //

    2803. 

  2803. $SPECIAL_MULTI = array(

    2804. 

  2804.         "conditions",

    2805. 

  2805.         "fmcompute",

    2806. 

  2806.         );

    2807. 

  2807. 

    2808. 

  2808.     //

    2809. 

  2809.     // $SPECIAL_ARRAYS is the list of fields from $SPECIAL_FIELDS that can

    2810. 

  2810.     // be submitted as arrays of values, for example:

    2811. 

  2811.     //      <select name="recipients[]">

    2812. 

  2812.     //      <option value="sales">Sales</option>

    2813. 

  2813.     //      <option value="service">Service</option>

    2814. 

  2814.     //      </select>

    2815. 

  2815.     //

    2816. 

  2816. $SPECIAL_ARRAYS = array(

    2817. 

  2817.         "recipients",

    2818. 

  2818.         "cc",

    2819. 

  2819.         "bcc",

    2820. 

  2820.         "replyto",

    2821. 

  2821.         );

    2822. 

  2822. 

    2823. 

  2823.     //

    2824. 

  2824.     // $SPECIAL_NOSTRIP is the list of fields from $SPECIAL_FIELDS that

    2825. 

  2825.     // should not be stripped (other than for magic_quotes_gpc reasons).

    2826. 

  2826.     //

    2827. 

  2827. $SPECIAL_NOSTRIP = array(

    2828. 

  2828.         "conditions",

    2829. 

  2829.         "fmcompute",

    2830. 

  2830.         "recaptcha_response_field",

    2831. 

  2831.         "recaptcha_challenge_field",

    2832. 

  2832.         );

    2833. 

  2833. 

    2834. 

  2834.     //

    2835. 

  2835.     // VALID_MAIL_OPTIONS lists the valid mail_options words

    2836. 

  2836.     //

    2837. 

  2837. $VALID_MAIL_OPTIONS = array(

    2838. 

  2838.         "AlwaysEmailFiles"=>true,

    2839. 

  2839.         "AlwaysList"=>true,

    2840. 

  2840.         "CharSet"=>true,

    2841. 

  2841.         "DupHeader"=>true,

    2842. 

  2842.         "Exclude"=>true,

    2843. 

  2843.         "FromAddr"=>true,

    2844. 

  2844.         "FromLineStyle"=>true,

    2845. 

  2845.         "HTMLTemplate"=>true,

    2846. 

  2846.         "KeepLines"=>true,

    2847. 

  2847.         "NoEmpty"=>true,

    2848. 

  2848.         "NoPlain"=>true,

    2849. 

  2849.         "PlainTemplate"=>true,

    2850. 

  2850.         "SendMailFOption"=>true,

    2851. 

  2851.         "StartLine"=>true,

    2852. 

  2852.         "TemplateMissing"=>true,

    2853. 

  2853.         );

    2854. 

  2854. 

    2855. 

  2855.     //

    2856. 

  2856.     // VALID_CRM_OPTIONS lists the valid crm_options words

    2857. 

  2857.     //

    2858. 

  2858. $VALID_CRM_OPTIONS = array(

    2859. 

  2859.         "ErrorOnFail"=>true,

    2860. 

  2860.         );

    2861. 

  2861. 

    2862. 

  2862.     //

    2863. 

  2863.     // VALID_AR_OPTIONS lists the valid autorespond words

    2864. 

  2864.     //

    2865. 

  2865. $VALID_AR_OPTIONS = array(

    2866. 

  2866.         "Subject"=>true,

    2867. 

  2867.         "HTMLTemplate"=>true,

    2868. 

  2868.         "PlainTemplate"=>true,

    2869. 

  2869.         "TemplateMissing"=>true,

    2870. 

  2870.         "PlainFile"=>true,

    2871. 

  2871.         "HTMLFile"=>true,

    2872. 

  2872.         "FromAddr"=>true,

    2873. 

  2873.         );

    2874. 

  2874. 

    2875. 

  2875.     //

    2876. 

  2876.     // VALID_FILTER_OPTIONS lists the valid filter_options words

    2877. 

  2877.     //

    2878. 

  2878. $VALID_FILTER_OPTIONS = array(

    2879. 

  2879.         "Attach"=>true,

    2880. 

  2880.         "KeepInLine"=>true,

    2881. 

  2881.         "CSVHeading"=>true,

    2882. 

  2882.         "CSVSep"=>true,

    2883. 

  2883.         "CSVIntSep"=>true,

    2884. 

  2884.         "CSVQuote"=>true,

    2885. 

  2885.         "CSVEscPolicy"=>true,

    2886. 

  2886.         "CSVRaw"=>true,

    2887. 

  2887.         );

    2888. 

  2888. 

    2889. 

  2889.     //

    2890. 

  2890.     // SPECIAL_VALUES is set to the value of the fields we've found

    2891. 

  2891.     //  usage: $SPECIAL_VALUES["email"] is the value of the email field

    2892. 

  2892.     //

    2893. 

  2893. $SPECIAL_VALUES = array();

    2894. 

  2894.     //

    2895. 

  2895.     // Array of mail options; set by the function 'ProcessMailOptions'

    2896. 

  2896.     //

    2897. 

  2897. $MAIL_OPTS = array();

    2898. 

  2898.     //

    2899. 

  2899.     // Array of crm options; set by the function 'ProcessCRMOptions'

    2900. 

  2900.     //

    2901. 

  2901. $CRM_OPTS = array();

    2902. 

  2902.     //

    2903. 

  2903.     // Array of autorespond options; set by the function 'ProcessAROptions'

    2904. 

  2904.     //

    2905. 

  2905. $AR_OPTS = array();

    2906. 

  2906.     //

    2907. 

  2907.     // Array of filter options; set by the function 'ProcessFilterOptions'

    2908. 

  2908.     //

    2909. 

  2909. $FILTER_OPTS = array();

    2910. 

  2910. 

    2911. 

  2911.     //

    2912. 

  2912.     // initialise $SPECIAL_VALUES so that we don't fail on using unset values

    2913. 

  2913.     //

    2914. 

  2914. foreach ($SPECIAL_FIELDS as $sFieldName)

    2915. 

  2915.     $SPECIAL_VALUES[$sFieldName] = "";

    2916. 

  2916. 

    2917. 

  2917.     //

    2918. 

  2918.     // Defaults for some special fields....

    2919. 

  2919.     //

    2920. 

  2920. $SPECIAL_VALUES['template_list_sep'] = ",";

    2921. 

  2921. 

    2922. 

  2922.     //

    2923. 

  2923.     // FORMATTED_INPUT contains the input variables formatted nicely

    2924. 

  2924.     // This is used for error reporting and debugging only.

    2925. 

  2925.     //

    2926. 

  2926. $FORMATTED_INPUT = array();

    2927. 

  2927. 

    2928. 

  2928.     //

    2929. 

  2929.     // $FILTER_ATTRIBS_LOOKUP is the parsed $FILTER_ATTRIBS array

    2930. 

  2930.     //

    2931. 

  2931. $FILTER_ATTRIBS_LOOKUP = array();

    2932. 

  2932. 

    2933. 

  2933.     //

    2934. 

  2934.     // $EMAIL_ADDRS is the array of email addresses from the $FORM_INI_FILE

    2935. 

  2935.     //

    2936. 

  2936. $EMAIL_ADDRS = array();

    2937. 

  2937. 

    2938. 

  2938. $reCaptchaProcessor = null;

    2939. 

  2939. if ($RECAPTCHA_PRIVATE_KEY !== "")

    2940. 

  2940. {

    2941. 

  2941.     require_once("recaptchalib.php");

    2942. 

  2942. 

    2943. 

  2943.     /*

    2944. 

  2944.      * Class:       reCaptchaWrapper

    2945. 

  2945.      * Description:     

    2946. 

  2946.      *  Wraps processing of reCaptcha.

    2947. 

  2947.      */

    2948. 

  2948.     class   reCaptchaWrapper

    2949. 

  2949.     {

    2950. 

  2950.         var     $_sPrivate;     // the private key

    2951. 

  2951.         var     $_bDone;        // true when done

    2952. 

  2952.         var     $_Resp;         // the response from reCaptcha

    2953. 

  2953. 

    2954. 

  2954.         /*

    2955. 

  2955.          * Method:      reCaptchaWrapper ctor

    2956. 

  2956.          * Parameters:  $s_priv     the private key

    2957. 

  2957.          * Returns:     n/a

    2958. 

  2958.          * Description: 

    2959. 

  2959.          *  Initializes the wrapper ready to process reCaptcha.

    2960. 

  2960.          */

    2961. 

  2961.         function    reCaptchaWrapper($s_priv)

    2962. 

  2962.         {

    2963. 

  2963.             $this->_sPrivate = $s_priv;

    2964. 

  2964.             $this->_bDone = false;

    2965. 

  2965.         }

    2966. 

  2966. 

    2967. 

  2967.         /*

    2968. 

  2968.          * Method:      reCaptchaWrapper::Check

    2969. 

  2969.          * Parameters:  $s_response the reCaptcha respone value

    2970. 

  2970.          *              $a_values   field values

    2971. 

  2971.          *              $s_error    returns the reCaptcha error code

    2972. 

  2972.          * Returns:     bool        true on success, otherwise false

    2973. 

  2973.          * Description: 

    2974. 

  2974.          *  Performs the reCaptcha check and caches the result so it's

    2975. 

  2975.          *  only done once.

    2976. 

  2976.          */

    2977. 

  2977.         function    Check($s_response,$a_values,&$s_error)

    2978. 

  2978.         {

    2979. 

  2979.             if (!$this->_bDone)

    2980. 

  2980.                 $this->_Resp = recaptcha_check_answer($this->_sPrivate,

    2981. 

  2981.                                                 $_SERVER["REMOTE_ADDR"],

    2982. 

  2982.                                                 $a_values["recaptcha_challenge_field"],

    2983. 

  2983.                                                 $s_response);

    2984. 

  2984.             $this->_bDone = true;

    2985. 

  2985.             $s_error = "";

    2986. 

  2986.             if (!$this->_Resp->is_valid)

    2987. 

  2987.                 $s_error = $this->_Resp->error;

    2988. 

  2988.             return ($this->_Resp->is_valid);

    2989. 

  2989.         }

    2990. 

  2990.     };

    2991. 

  2991. 

    2992. 

  2992.     $reCaptchaProcessor = new reCaptchaWrapper($RECAPTCHA_PRIVATE_KEY);

    2993. 

  2993. }

    2994. 

  2994. 

    2995. 

  2995. /* 

    2996. 

  2996.  * Class:       EmailChecker

    2997. 

  2997.  * Description:     

    2998. 

  2998.  *  Contains a list of valid email addresses and email address patterns.

    2999. 

  2999.  *  Provides methods for checking the validity of an email address.

    3000. 

  3000.  */

    3001. 

  3001. class   EmailChecker

    3002. 

  3002. {

    3003. 

  3003.     var     $_aAddresses;       // valid email addresses (as keys)

    3004. 

  3004.     var     $_aTargetPatterns;  // valid email address patterns

    3005. 

  3005. 

    3006. 

  3006.     /*

    3007. 

  3007.      * Method:      EmailChecker ctor

    3008. 

  3008.      * Parameters:  $a_patterns     an array of email address patterns

    3009. 

  3009.      * Returns:     n/a

    3010. 

  3010.      * Description: 

    3011. 

  3011.      *  Constructs the object.

    3012. 

  3012.      */

    3013. 

  3013.     function    EmailChecker($a_patterns = array())

    3014. 

  3014.     {

    3015. 

  3015.         $this->_aAddresses = array();

    3016. 

  3016.         $this->_aTargetPatterns = $a_patterns;

    3017. 

  3017.     }

    3018. 

  3018. 

    3019. 

  3019.     /*

    3020. 

  3020.      * Method:      EmailChecker::AddAddress

    3021. 

  3021.      * Parameters:  $s_addr     an email address

    3022. 

  3022.      * Returns:     void

    3023. 

  3023.      * Description: 

    3024. 

  3024.      *  Adds an email address to the list of valid email addresses.

    3025. 

  3025.      */

    3026. 

  3026.     function    AddAddress($s_addr)

    3027. 

  3027.     {

    3028. 

  3028.         $this->_aAddresses[$s_addr] = true;

    3029. 

  3029.     }

    3030. 

  3030. 

    3031. 

  3031.     /*

    3032. 

  3032.      * Method:      EmailChecker::AddAddresses

    3033. 

  3033.      * Parameters:  $s_list     a list ofemail addresses

    3034. 

  3034.      * Returns:     void

    3035. 

  3035.      * Description: 

    3036. 

  3036.      *  Adds a comma-separated list of email addresses to the list of valid email addresses.

    3037. 

  3037.      */

    3038. 

  3038.     function    AddAddresses($s_list)

    3039. 

  3039.     {

    3040. 

  3040.         $a_addrs = TrimArray(explode(",",$s_list));

    3041. 

  3041.         foreach ($a_addrs as $s_addr)

    3042. 

  3042.             $this->AddAddress($s_addr);

    3043. 

  3043.     }

    3044. 

  3044. 

    3045. 

  3045.     /*

    3046. 

  3046.      * Method:      EmailChecker::CheckAddress

    3047. 

  3047.      * Parameters:  $s_email    an email address

    3048. 

  3048.      * Returns:     bool        true if the address is valid, otherwise false

    3049. 

  3049.      * Description: 

    3050. 

  3050.      *  Checks an email address for validity.

    3051. 

  3051.      */

    3052. 

  3052.     function    CheckAddress($s_email)

    3053. 

  3053.     {

    3054. 

  3054.         $b_is_valid = false;

    3055. 

  3055.         if (isset($this->_aAddresses[$s_email]))

    3056. 

  3056.             $b_is_valid = true;

    3057. 

  3057.         else

    3058. 

  3058.         {

    3059. 

  3059.             for ($ii = 0 ; $ii < count($this->_aTargetPatterns) ; $ii++)

    3060. 

  3060.             {

    3061. 

  3061.                     //

    3062. 

  3062.                     // prepend / with \

    3063. 

  3063.                     //

    3064. 

  3064.                 $s_pat = "/".str_replace('/','\\/',$this->_aTargetPatterns[$ii])."/i";

    3065. 

  3065.                 if (preg_match($s_pat,$s_email))

    3066. 

  3066.                 {

    3067. 

  3067.                     $b_is_valid = true;

    3068. 

  3068.                     break;

    3069. 

  3069.                 }

    3070. 

  3070.             }

    3071. 

  3071.         }

    3072. 

  3072.         return ($b_is_valid);

    3073. 

  3073.     }

    3074. 

  3074. };

    3075. 

  3075. 

    3076. 

  3076.     //

    3077. 

  3077.     // Create the object for checking emails

    3078. 

  3078.     //

    3079. 

  3079. $ValidEmails = new EmailChecker($TARGET_EMAIL);

    3080. 

  3080. 

    3081. 

  3081. /*

    3082. 

  3082.  * Class:       FieldManager

    3083. 

  3083.  * Description:     

    3084. 

  3084.  *  Encapsulates storage and lookup of field data.

    3085. 

  3085.  *  NOTE: this is initial code implemented in version 8.27 and is not complete.

    3086. 

  3086.  *  It's part of our transition to a more complete Object Oriented code base

    3087. 

  3087.  *  which is targeted for version 9.00.

    3088. 

  3088.  */

    3089. 

  3089. class   FieldManager

    3090. 

  3090. {

    3091. 

  3091.     var     $_aFields;      // list of fields keyed by field name

    3092. 

  3092.     var     $_aFileFields;  // list of file fields keyed by field name (not currently used)

    3093. 

  3093.     var     $_sArraySep;        // last array separator specified

    3094. 

  3094.     var     $_sArraySepValue;   // array separator to use (after substitutions)

    3095. 

  3095.     var     $_nUnique;      // counter for unique string generation

    3096. 

  3096. 

    3097. 

  3097.     /*

    3098. 

  3098.      * Method:      FieldManager ctor

    3099. 

  3099.      * Parameters:  $a_fields       list of fields

    3100. 

  3100.      *              $a_file_fields  list of file fields

    3101. 

  3101.      * Returns:     n/a

    3102. 

  3102.      * Description: 

    3103. 

  3103.      *  Constructs the object.

    3104. 

  3104.      */

    3105. 

  3105.     function    FieldManager($a_fields = array(),$a_file_fields = array())

    3106. 

  3106.     {

    3107. 

  3107.         $this->_sArraySepValue = $this->_sArraySep = "";

    3108. 

  3108.         $this->_aFields = $this->_aFileFields = array();

    3109. 

  3109.         $this->_nUnique = 0;

    3110. 

  3110.         $this->Init($a_fields,$a_file_fields);

    3111. 

  3111.     }

    3112. 

  3112. 

    3113. 

  3113.     /*

    3114. 

  3114.      * Method:      FieldManager::Init

    3115. 

  3115.      * Parameters:  $a_fields       list of fields

    3116. 

  3116.      *              $a_file_fields  list of file fields

    3117. 

  3117.      * Returns:     void

    3118. 

  3118.      * Description: 

    3119. 

  3119.      *  Initializes the object with the field data.

    3120. 

  3120.      */

    3121. 

  3121.     function    Init($a_fields,$a_file_fields)

    3122. 

  3122.     {

    3123. 

  3123.         $this->_aFields = $a_fields;

    3124. 

  3124.         $this->_aFileFields = $a_file_fields;

    3125. 

  3125.     }

    3126. 

  3126. 

    3127. 

  3127.     /*

    3128. 

  3128.      * Method:      FieldManager::GetFieldValue

    3129. 

  3129.      * Parameters:  $s_fld          name of the field

    3130. 

  3130.      *              $s_array_sep    string to use to separate array values

    3131. 

  3131.      * Returns:     string          the field's value

    3132. 

  3132.      * Description: 

    3133. 

  3133.      *      Return a field value.  Empty string is returned if the field is

    3134. 

  3134.      *      not found. File fields return the original name of the uploaded file.

    3135. 

  3135.      */

    3136. 

  3136.     function GetFieldValue($s_fld,$s_array_sep = ";")

    3137. 

  3137.     {

    3138. 

  3138.         if (!isset($this->_aFields[$s_fld]))

    3139. 

  3139.         {

    3140. 

  3140.             if (($s_name = GetFileName($s_fld)) === false)

    3141. 

  3141.                 $s_name = "";

    3142. 

  3142.             $s_value = $s_name;

    3143. 

  3143.         }

    3144. 

  3144.         if (is_array($this->_aFields[$s_fld]))

    3145. 

  3145.             $s_value = implode($this->_GetArraySep($s_array_sep),$this->_aFields[$s_fld]);

    3146. 

  3146.         else

    3147. 

  3147.             $s_value = (string) $this->_aFields[$s_fld];

    3148. 

  3148.         return ($s_value);

    3149. 

  3149.     }

    3150. 

  3150. 

    3151. 

  3151.     /*

    3152. 

  3152.      * Method:      FieldManager::GetSafeFieldValue

    3153. 

  3153.      * Parameters:  $s_fld          name of the field

    3154. 

  3154.      *              $b_text_subs    perform text substitutions

    3155. 

  3155.      *              $s_array_sep    string to use to separate array values

    3156. 

  3156.      * Returns:     string          the field's value

    3157. 

  3157.      * Description: 

    3158. 

  3158.      *      Return a field value.  Empty string is returned if the field is

    3159. 

  3159.      *      not found. File fields return the original name of the uploaded file.

    3160. 

  3160.      *      The returned value is HTML-safe.

    3161. 

  3161.      *      b_text_subs performs text substitutions on the field value

    3162. 

  3162.      *      that are not affected by HTML-safety replacement.  This means

    3163. 

  3163.      *      $TEXT_SUBS can be used to force allowance of particular HTML

    3164. 

  3164.      *      tags.  Note that b_text_subs is not yet implemented for array field

    3165. 

  3165.      *      values.

    3166. 

  3166.      */

    3167. 

  3167.     function GetSafeFieldValue($s_fld,$b_text_subs = false,$s_array_sep = ";")

    3168. 

  3168.     {

    3169. 

  3169.             //

    3170. 

  3170.             // for array values, insert the array separator after making

    3171. 

  3171.             // the individual values HTML-safe

    3172. 

  3172.             // The equivalent logic up to and including version 8.24 used

    3173. 

  3173.             // htmlspecialchars not htmlentities.

    3174. 

  3174.             // The use of htmlentities broke UTF-8 template processing,

    3175. 

  3175.             // and this was reported in version 8.28.

    3176. 

  3176.             // By specifying the character set, we trigger the use of htmlspecialchars

    3177. 

  3177.             // so the logic is equivalent to the old logic.

    3178. 

  3178.             //

    3179. 

  3179.         if (isset($this->_aFields[$s_fld]) && is_array($this->_aFields[$s_fld]))

    3180. 

  3180.             $s_value = implode($this->_GetArraySep($s_array_sep),

    3181. 

  3181.                             HTMLEntitiesArray($this->_aFields[$s_fld],false,

    3182. 

  3182.                                 GetMailOption("CharSet")));

    3183. 

  3183.         else

    3184. 

  3184.         {

    3185. 

  3185.             if (!isset($this->_aFields[$s_fld]))

    3186. 

  3186.             {

    3187. 

  3187.                 if (($s_name = GetFileName($s_fld)) === false)

    3188. 

  3188.                     $s_name = "";

    3189. 

  3189.                 $s_value = $s_name;

    3190. 

  3190.             }

    3191. 

  3191.             else

    3192. 

  3192.                 $s_value = (string) $this->_aFields[$s_fld];

    3193. 

  3193.             if ($b_text_subs)

    3194. 

  3194.                 list($s_value,$a_subs_data) = $this->_PrepareTextSubstitute($s_value);

    3195. 

  3195.             $s_value = FixedHTMLEntities($s_value,GetMailOption("CharSet"));

    3196. 

  3196.             if ($b_text_subs)

    3197. 

  3197.                 $s_value = $this->_CompleteTextSubstitute($s_value,$a_subs_data);

    3198. 

  3198.         }

    3199. 

  3199.         return ($s_value);

    3200. 

  3200.     }

    3201. 

  3201. 

    3202. 

  3202.     /*

    3203. 

  3203.      * Method:      FieldManager::_PrepareTextSubstitute

    3204. 

  3204.      * Parameters:  $s_value    the value to perform substitutions on

    3205. 

  3205.      * Returns:     array       [0]=>the processed value, [1]=>array of substitution data

    3206. 

  3206.      * Description:

    3207. 

  3207.      *  Prepares a value for text substitution using $TEXT_SUBS.

    3208. 

  3208.      *  Requires PHP 4.3.0 or later.

    3209. 

  3209.      */

    3210. 

  3210.     function _PrepareTextSubstitute($s_value)

    3211. 

  3211.     {

    3212. 

  3212.         global $TEXT_SUBS;

    3213. 

  3213. 

    3214. 

  3214.         $a_subs_data = array();

    3215. 

  3215.         if (!IsPHPAtLeast("4.3.0"))

    3216. 

  3216.             SendAlert("The text substitution feature requires PHP version 4.3.0 or later");

    3217. 

  3217.         else

    3218. 

  3218.         {

    3219. 

  3219.             for ($ii = 0; $ii < count($TEXT_SUBS); $ii++)

    3220. 

  3220.             {

    3221. 

  3221.                 $a_match_data = array();

    3222. 

  3222.                 if (($n_matches = preg_match_all($TEXT_SUBS[$ii]["srch"],

    3223. 

  3223.                                     $s_value,$a_matches,

    3224. 

  3224.                                     PREG_OFFSET_CAPTURE)) !== false && $n_matches > 0)

    3225. 

  3225.                 {

    3226. 

  3226.                     $a_match_data["srch"] = $TEXT_SUBS[$ii]["srch"];

    3227. 

  3227.                     $a_match_data["repl"] = $TEXT_SUBS[$ii]["repl"];

    3228. 

  3228.                     $s_value = $this->_HTMLSafeSubstitute($s_value,$a_matches,$a_match_data);

    3229. 

  3229.                 }

    3230. 

  3230.                 $a_subs_data[$ii] = $a_match_data;

    3231. 

  3231.             }

    3232. 

  3232.         }

    3233. 

  3233.         return (array($s_value,$a_subs_data));

    3234. 

  3234.     }

    3235. 

  3235. 

    3236. 

  3236.     /*

    3237. 

  3237.      * Method:      FieldManager::_CompleteTextSubstitute

    3238. 

  3238.      * Parameters:  $s_value    the value to perform substitutions on

    3239. 

  3239.      *              $a_subs_data data that describes the substitutions to perform

    3240. 

  3240.      * Returns:     string      the new value

    3241. 

  3241.      * Description:

    3242. 

  3242.      *  Completes text substitution started by _PrepareTextSubstitute.

    3243. 

  3243.      */

    3244. 

  3244.     function _CompleteTextSubstitute($s_value,$a_subs_data)

    3245. 

  3245.     {

    3246. 

  3246.             //

    3247. 

  3247.             // because later substitutions can capture earlier ones,

    3248. 

  3248.             // we have to process them all in reverse order

    3249. 

  3249.             //

    3250. 

  3250.         for ($ii = count($a_subs_data) ; --$ii >= 0 ; )

    3251. 

  3251.         {

    3252. 

  3252.             $a_subs_list = $a_subs_data[$ii];

    3253. 

  3253.             for ($jj = count($a_subs_list) ; --$jj >= 0 ; )

    3254. 

  3254.             {

    3255. 

  3255.                 $s_code = $a_subs_list[$jj]["code"];

    3256. 

  3256.                 $s_subs = $a_subs_list[$jj]["subs"];

    3257. 

  3257.                 $s_value = str_replace($s_code,$s_subs,$s_value);

    3258. 

  3258.             }

    3259. 

  3259.         }

    3260. 

  3260.         return ($s_value);

    3261. 

  3261.     }

    3262. 

  3262. 

    3263. 

  3263.     /*

    3264. 

  3264.      * Method:      FieldManager::_MakeUniqueString

    3265. 

  3265.      * Parameters:  $s_base a base of the unique string

    3266. 

  3266.      * Returns:     string  a unique string

    3267. 

  3267.      * Description:

    3268. 

  3268.      *  Generates a unique string from a base string

    3269. 

  3269.      */

    3270. 

  3270.     function _MakeUniqueString($s_base)

    3271. 

  3271.     {

    3272. 

  3272.         $n_uniq = $this->_nUnique++;

    3273. 

  3273.         return ($s_base."_".str_pad("$n_uniq",5,"0",STR_PAD_LEFT));

    3274. 

  3274.     }

    3275. 

  3275. 

    3276. 

  3276.     /*

    3277. 

  3277.      * Method:      FieldManager::_HTMLSafeSubstitute

    3278. 

  3278.      * Parameters:  $s_value    the string to substitute 

    3279. 

  3279.      *              $a_matches  list of matches and offsets from preg_match_all

    3280. 

  3280.      *              $a_match_data   contains some data, and returns replacement data

    3281. 

  3281.      *                          for the temporary substitution

    3282. 

  3282.      * Returns:     string      the temporarily substituted string

    3283. 

  3283.      * Description:

    3284. 

  3284.      *  Performs a temporary substitution on a string of the given matches with

    3285. 

  3285.      *  the given replacement specification. This makes the replacement using

    3286. 

  3286.      *  a special indicator string that can be substituted for the real value

    3287. 

  3287.      *  later.  This allows non-replaced parts of the string to be processed

    3288. 

  3288.      *  and made safe for HTML entities, without affecting our actual replacements.

    3289. 

  3289.      */

    3290. 

  3290.     function _HTMLSafeSubstitute($s_value,$a_matches,&$a_match_data)

    3291. 

  3291.     {

    3292. 

  3292.         $a_matches = $a_matches[0]; // we're only interested in the full pattern matches

    3293. 

  3293.         $s_srch = $a_match_data["srch"];

    3294. 

  3294.         $s_repl = $a_match_data["repl"];

    3295. 

  3295. 

    3296. 

  3296.             //

    3297. 

  3297.             // to preserve offsets, we must process the string in reverse order

    3298. 

  3298.             // of the matches; since we don't assume the array is ordered

    3299. 

  3299.             // by ascending offset, we'll sort it now

    3300. 

  3300.             //

    3301. 

  3301.         usort($a_matches,create_function('$a,$b','return $b[1] - $a[1];'));

    3302. 

  3302.         $a_match_data = array();

    3303. 

  3303.         for ($ii = 0; $ii < count($a_matches); $ii++)

    3304. 

  3304.         {

    3305. 

  3305.             $s_match = $a_matches[$ii][0];

    3306. 

  3306.             $i_offset = $a_matches[$ii][1];

    3307. 

  3307.             $i_len = strlen($s_match);

    3308. 

  3308. 

    3309. 

  3309.             $s_subs = preg_replace($s_srch,$s_repl,$s_match);

    3310. 

  3310.                 //

    3311. 

  3311.                 // the code string must e HTML safe so it doesn't get altered

    3312. 

  3312.                 // before we can replace it; we use ! at the edges so that

    3313. 

  3313.                 // other patterns can successfully match word boundaries

    3314. 

  3314.                 // An improvement would be to determine the type of characters

    3315. 

  3315.                 // at the edges of the matched string, then choose the substitution

    3316. 

  3316.                 // edges accordingly.

    3317. 

  3317.                 //

    3318. 

  3318.             $s_code = "!".$this->_MakeUniqueString("SUBS")."!";

    3319. 

  3319.             $a_match_data[$ii] = array("subs"=>$s_subs,"code"=>$s_code);

    3320. 

  3320. 

    3321. 

  3321.             $s_value = substr($s_value,0,$i_offset).$s_code.

    3322. 

  3322.                 substr($s_value,$i_offset + $i_len);

    3323. 

  3323.         }

    3324. 

  3324.         return ($s_value);

    3325. 

  3325.     }

    3326. 

  3326. 

    3327. 

  3327.     /*

    3328. 

  3328.      * Method:      FieldManager::IsFieldSet

    3329. 

  3329.      * Parameters:  $s_fld      name of the field

    3330. 

  3330.      * Returns:     bool        true if the field has a value

    3331. 

  3331.      * Description: 

    3332. 

  3332.      *  Test if a field is set in the $_aFields array or in the uploaded

    3333. 

  3333.      *  files.

    3334. 

  3334.      */

    3335. 

  3335.     /*static*/ function    IsFieldSet($s_fld)

    3336. 

  3336.     {

    3337. 

  3337.         global  $aFileVars;     // temporary code until this class is complete

    3338. 

  3338. 

    3339. 

  3339.         if (isset($this->_aFields[$s_fld]))

    3340. 

  3340.             return (true);

    3341. 

  3341.         if (FILEUPLOADS)

    3342. 

  3342.         {

    3343. 

  3343.             if (isset($aFileVars[$s_fld]))

    3344. 

  3344.                 return (true);

    3345. 

  3345.             if (IsSetSession("FormSavedFiles"))

    3346. 

  3346.             {

    3347. 

  3347.                 $a_saved_files = GetSession("FormSavedFiles");

    3348. 

  3348.                 if (isset($a_saved_files[$s_fld]))

    3349. 

  3349.                     return (true);

    3350. 

  3350.             }

    3351. 

  3351.         }

    3352. 

  3352.         return (false);

    3353. 

  3353.     }

    3354. 

  3354. 

    3355. 

  3355.     /*

    3356. 

  3356.      * Method:      FieldManager::TestFieldEmpty

    3357. 

  3357.      * Parameters:  $s_fld      name of the field

    3358. 

  3358.      *              $s_mesg     returns an error message, where possible

    3359. 

  3359.      * Returns:     bool        true if the field is empty

    3360. 

  3360.      * Description: 

    3361. 

  3361.      *  Tests a field against the $_aFields array for emptyness.

    3362. 

  3362.      *  If the var isn't found there, then the POSTed files array is checked.

    3363. 

  3363.      *  Returns true if the field is empty (a specific error may

    3364. 

  3364.      *  be returned in the $s_mesg parameter).

    3365. 

  3365.      */

    3366. 

  3366.     /*static*/ function TestFieldEmpty($s_fld,&$s_mesg)

    3367. 

  3367.     {

    3368. 

  3368.         global  $aFileVars;         // temporary until code completed

    3369. 

  3369. 

    3370. 

  3370.         $s_mesg = "";

    3371. 

  3371.         $b_empty = TRUE;

    3372. 

  3372.         if (!isset($this->_aFields[$s_fld]))

    3373. 

  3373.         {

    3374. 

  3374.                 //

    3375. 

  3375.                 // Each file var is an array with these elements:

    3376. 

  3376.                 //      "name" => The original name of the file on the client machine.

    3377. 

  3377.                 //      "type" => The mime type of the file, if the browser provided this information.

    3378. 

  3378.                 //      "tmp_name" => The temporary filename of the file in which the uploaded file was stored on the server.

    3379. 

  3379.                 //      "error" => The error code associated with this file upload.

    3380. 

  3380.                 //                  NOTE: "error" was added in PHP 4.2.0

    3381. 

  3381.                 //      "size" => The size, in bytes, of the uploaded file.

    3382. 

  3382.                 //

    3383. 

  3383.                 // Error codes (the constants are only available from PHP 4.3.0 so

    3384. 

  3384.                 // we have to use the raw numbers):

    3385. 

  3385.                 //  UPLOAD_ERR_OK

    3386. 

  3386.                 //      Value: 0; There is no error, the file uploaded with success.

    3387. 

  3387.                 //  UPLOAD_ERR_INI_SIZE

    3388. 

  3388.                 //      Value: 1; The uploaded file exceeds the upload_max_filesize directive in php.ini.

    3389. 

  3389.                 //  UPLOAD_ERR_FORM_SIZE

    3390. 

  3390.                 //      Value: 2; The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the html form.

    3391. 

  3391.                 //  UPLOAD_ERR_PARTIAL

    3392. 

  3392.                 //      Value: 3; The uploaded file was only partially uploaded.

    3393. 

  3393.                 //  UPLOAD_ERR_NO_FILE

    3394. 

  3394.                 //      Value: 4; No file was uploaded.

    3395. 

  3395.                 //

    3396. 

  3396.             if (FILEUPLOADS)

    3397. 

  3397.             {

    3398. 

  3398.                 if (IsSetSession("FormSavedFiles"))

    3399. 

  3399.                 {

    3400. 

  3400.                     $a_saved_files = GetSession("FormSavedFiles");

    3401. 

  3401.                     if (isset($a_saved_files[$s_fld]))

    3402. 

  3402.                         $a_upload = $a_saved_files[$s_fld];

    3403. 

  3403.                     elseif (isset($aFileVars[$s_fld]))

    3404. 

  3404.                         $a_upload = $aFileVars[$s_fld];

    3405. 

  3405.                 }

    3406. 

  3406.                 elseif (isset($aFileVars[$s_fld]))

    3407. 

  3407.                     $a_upload = $aFileVars[$s_fld];

    3408. 

  3408.             }

    3409. 

  3409.             if (isset($a_upload))

    3410. 

  3410.             {

    3411. 

  3411.                 if (isset($a_upload["tmp_name"]) && !empty($a_upload["tmp_name"]) &&

    3412. 

  3412.                     isset($a_upload["name"]) && !empty($a_upload["name"]))

    3413. 

  3413.                 {

    3414. 

  3414.                     if (IsUploadedFile($a_upload))

    3415. 

  3415.                         $b_empty = false;

    3416. 

  3416.                 }

    3417. 

  3417.                 if ($b_empty && isset($a_upload["error"]))

    3418. 

  3418.                     switch ($a_upload["error"])

    3419. 

  3419.                     {

    3420. 

  3420.                     case 1:

    3421. 

  3421.                         $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR1);

    3422. 

  3422.                         break;

    3423. 

  3423.                     case 2:

    3424. 

  3424.                         $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR2);

    3425. 

  3425.                         break;

    3426. 

  3426.                     case 3:

    3427. 

  3427.                         $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR3);

    3428. 

  3428.                         break;

    3429. 

  3429.                     case 4:

    3430. 

  3430.                         $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR4);

    3431. 

  3431.                         break;

    3432. 

  3432.                     case 6:

    3433. 

  3433.                         $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR6);

    3434. 

  3434.                         break;

    3435. 

  3435.                     case 7:

    3436. 

  3436.                         $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR7);

    3437. 

  3437.                         break;

    3438. 

  3438.                     case 8:

    3439. 

  3439.                         $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR8);

    3440. 

  3440.                         break;

    3441. 

  3441.                     default:

    3442. 

  3442.                         $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR_UNK,

    3443. 

  3443.                                         array("ERRNO"=>$a_upload["error"]));

    3444. 

  3444.                         break;

    3445. 

  3445.                     }

    3446. 

  3446.             }

    3447. 

  3447.         }

    3448. 

  3448.         else

    3449. 

  3449.             $b_empty = FieldManager::IsEmpty($this->_aFields[$s_fld]);

    3450. 

  3450.         return ($b_empty);

    3451. 

  3451.     }

    3452. 

  3452. 

    3453. 

  3453.     /*

    3454. 

  3454.      * Method:      FieldManager::IsEmpty

    3455. 

  3455.      * Parameters:  $s_value    the value to test

    3456. 

  3456.      * Returns:     bool        true if the value is "empty"

    3457. 

  3457.      * Description: 

    3458. 

  3458.      *  Same as "empty" but checks for true emptiness if ZERO_IS_EMPTY is

    3459. 

  3459.      *  set to false.

    3460. 

  3460.      */

    3461. 

  3461.     /*static*/ function IsEmpty($s_value)

    3462. 

  3462.     {

    3463. 

  3463.         if (ZERO_IS_EMPTY || is_array($s_value))

    3464. 

  3464.             return (empty($s_value));

    3465. 

  3465.         else

    3466. 

  3466.             return ($s_value === "");

    3467. 

  3467.     }

    3468. 

  3468. 

    3469. 

  3469.     /*

    3470. 

  3470.      * Method:      FieldManager::Substitute

    3471. 

  3471.      * Parameters:  $s_str      a string on which to perform substitutions

    3472. 

  3472.      * Returns:     string      the string, substituted

    3473. 

  3473.      * Description: 

    3474. 

  3474.      *  Makes substitutions on strings as specified in the configuration setting

    3475. 

  3475.      *  $TEXT_SUBS.

    3476. 

  3476.      */

    3477. 

  3477.     /*static*/ function    Substitute($s_str)

    3478. 

  3478.     {

    3479. 

  3479.         global  $TEXT_SUBS;

    3480. 

  3480. 

    3481. 

  3481.         $a_srch = $a_repl = array();

    3482. 

  3482.         foreach ($TEXT_SUBS as $a_sub)

    3483. 

  3483.         {

    3484. 

  3484.             if (isset($a_sub["srch"]) &&

    3485. 

  3485.                 isset($a_sub["repl"]) &&

    3486. 

  3486.                 $a_sub["srch"] !== "")

    3487. 

  3487.             {

    3488. 

  3488.                 $a_srch[] = $a_sub["srch"];

    3489. 

  3489.                 $a_repl[] = $a_sub["repl"];

    3490. 

  3490.             }

    3491. 

  3491.         }

    3492. 

  3492.         return (preg_replace($a_srch,$a_repl,$s_str));

    3493. 

  3493.     }

    3494. 

  3494. 

    3495. 

  3495.     /*

    3496. 

  3496.      * Method:      FieldManager::_GetArraySep 

    3497. 

  3497.      * Parameters:  $s_sep      the string specified for array separations

    3498. 

  3498.      * Returns:     string      the string to use for array separations

    3499. 

  3499.      * Description: 

    3500. 

  3500.      *  Computes the array separation string.  $s_sep is subject to

    3501. 

  3501.      *  subsititions specified in $TEXT_SUBS, and then returned.

    3502. 

  3502.      */

    3503. 

  3503.     function    _GetArraySep($s_sep)

    3504. 

  3504.     {

    3505. 

  3505.             //

    3506. 

  3506.             // check for cached (previously calculated) value

    3507. 

  3507.             //

    3508. 

  3508.         if ($s_sep !== $this->_sArraySep)

    3509. 

  3509.         {

    3510. 

  3510.             $this->_sArraySep = $s_sep;

    3511. 

  3511.             $this->_sArraySepValue = FieldManager::Substitute($this->_sArraySep);

    3512. 

  3512.         }

    3513. 

  3513.         return ($this->_sArraySepValue);

    3514. 

  3514.     }

    3515. 

  3515. }

    3516. 

  3516. 

    3517. 

  3517.     //

    3518. 

  3518.     // Peform general line folding.

    3519. 

  3519.     // This function can be used for RFC 2822 line folding, as well

    3520. 

  3520.     // Quoted Printable soft line breaks (RFC 2045).

    3521. 

  3521.     // $s_before lists the characters before which we should fold the line.

    3522. 

  3522.     // $s_after lists the characters after which we should fold the line.

    3523. 

  3523.     // $s_fold is the string to insert to fold the line.

    3524. 

  3524.     //

    3525. 

  3525. function    LineFolding($s_str,$i_max_line,$s_before,$s_after,$s_fold)

    3526. 

  3526. {

    3527. 

  3527.     $i_str_len = strlen($s_str);

    3528. 

  3528.     $ii = $i_start = 0;

    3529. 

  3529.     $i_line_len = 0;

    3530. 

  3530.     while ($ii < $i_str_len)

    3531. 

  3531.     {

    3532. 

  3532.         if ($i_line_len == $i_max_line)

    3533. 

  3533.         {

    3534. 

  3534.                 //

    3535. 

  3535.                 // fold this line:

    3536. 

  3536.                 // search backwards for a character at which we can

    3537. 

  3537.                 // fold the line

    3538. 

  3538.                 //

    3539. 

  3539.             $b_done = false;

    3540. 

  3540.             for ($jj = $ii ; !$b_done && $jj > $i_start ; $jj--)

    3541. 

  3541.             {

    3542. 

  3542.                 $b_found = false;

    3543. 

  3543.                 if (strpos($s_before,$s_str[$jj]) !== false)

    3544. 

  3544.                 {

    3545. 

  3545.                         //

    3546. 

  3546.                         // fold before this character

    3547. 

  3547.                         //

    3548. 

  3548.                     $b_found = true;

    3549. 

  3549.                 }

    3550. 

  3550.                 elseif (strpos($s_after,$s_str[$jj]) !== false)

    3551. 

  3551.                 {

    3552. 

  3552.                         //

    3553. 

  3553.                         // fold after this character

    3554. 

  3554.                         //

    3555. 

  3555.                     $jj++;

    3556. 

  3556.                     $b_found = true;

    3557. 

  3557.                 }

    3558. 

  3558.                 if ($b_found)

    3559. 

  3559.                 {

    3560. 

  3560.                     $s_str = substr($s_str,0,$jj).$s_fold.substr($s_str,$jj);

    3561. 

  3561.                     $i_fold_len = strlen($s_fold);

    3562. 

  3562.                     $i_str_len += $i_fold_len;        // the additional chars we inserted

    3563. 

  3563.                     $i_start = $jj + $i_fold_len; // start of the next line

    3564. 

  3564.                     $b_done = true;

    3565. 

  3565.                 }

    3566. 

  3566.             }

    3567. 

  3567.                 //

    3568. 

  3568.                 // if we cannot fold and shorten the line, 

    3569. 

  3569.                 // ignore this and try for the next line

    3570. 

  3570.                 //

    3571. 

  3571.             if ($b_done)

    3572. 

  3572.                 $ii = $i_start;

    3573. 

  3573.             else

    3574. 

  3574.                 $i_start = $ii;

    3575. 

  3575.             $i_line_len = 0;

    3576. 

  3576.         }

    3577. 

  3577.         elseif (substr($s_str,$ii,2) == "\r\n")

    3578. 

  3578.         {

    3579. 

  3579.                 //

    3580. 

  3580.                 // end of line found - reset counters

    3581. 

  3581.                 //

    3582. 

  3582.             $i_line_len = 0;

    3583. 

  3583.             $ii += 2;

    3584. 

  3584.             $i_start = $ii;

    3585. 

  3585.         }

    3586. 

  3586.         else

    3587. 

  3587.         {

    3588. 

  3588.             $ii++;

    3589. 

  3589.             $i_line_len++;

    3590. 

  3590.         }

    3591. 

  3591.     }

    3592. 

  3592.     return ($s_str);

    3593. 

  3593. }

    3594. 

  3594. 

    3595. 

  3595.     //

    3596. 

  3596.     // Quoted Printable Encoding with soft line breaks.

    3597. 

  3597.     //

    3598. 

  3598.     // Process a string to fit the requirements of RFC2045 section 6.7. Note that

    3599. 

  3599.     // this works, but replaces more characters than the minimum set.

    3600. 

  3600.     // Prior to version 8.34, for readability the spaces were not encoded, which was

    3601. 

  3601.     // WRONG (see http://tools.ietf.org/html/rfc2047#section-2).  Spaces must

    3602. 

  3602.     // be encoded.

    3603. 

  3603.     //

    3604. 

  3604.     // Adapted from:

    3605. 

  3605.     //  http://www.php.net/manual/en/function.quoted-printable-decode.php

    3606. 

  3606.     // Note that we *must* split long lines because a QP string might not

    3607. 

  3607.     // contain any Folding White Space (FWS). In this case, it would

    3608. 

  3608.     // not be possible to fold the line according to RFC 2822.

    3609. 

  3609.     // Therefore, we need to use Soft Line Breaks as defined by the

    3610. 

  3610.     // Quoted Printable definition in RFC 2045.

    3611. 

  3611.     //

    3612. 

  3612.     // Set $i_max_line to -ve to skip the line folding.

    3613. 

  3613.     //

    3614. 

  3614. function    QPEncode($s_str,$i_max_line)

    3615. 

  3615. {

    3616. 

  3616.         //

    3617. 

  3617.         // According to RFC2045 section 6.7 point (4), we need to keep any

    3618. 

  3618.         // actual \r\n breaks encoded in the QP.  The original code replaced

    3619. 

  3619.         // them with CRLF pairs.

    3620. 

  3620.         //

    3621. 

  3621.     $s_str = str_replace('%','=',rawurlencode($s_str));

    3622. 

  3622.     if ($i_max_line < 0)

    3623. 

  3623.         return ($s_str);

    3624. 

  3624.     else

    3625. 

  3625.     {

    3626. 

  3626.         $s_before = "=";       // characters before which we can fold the line

    3627. 

  3627.         return (LineFolding($s_str,$i_max_line,$s_before,"","=\r\n"));

    3628. 

  3628.     }

    3629. 

  3629. }

    3630. 

  3630. 

    3631. 

  3631.     //

    3632. 

  3632.     // Peform header line folding according to RFC 2822.

    3633. 

  3633.     // $s_before lists the characters before which we should fold the line.

    3634. 

  3634.     // $s_after lists the characters after which we should fold the line.

    3635. 

  3635.     // Characters left out of folding:

    3636. 

  3636.     //      [] are part of no-fold-literal

    3637. 

  3637.     //      () are part of comments, and should work, but don't

    3638. 

  3638.     //

    3639. 

  3639. function    HeaderFolding($s_str,$i_max_line = RFCLINELEN,$s_before = "<",$s_after = ">;, ")

    3640. 

  3640. {

    3641. 

  3641.     return (LineFolding($s_str,$i_max_line,$s_before,$s_after,"\r\n "));

    3642. 

  3642. }

    3643. 

  3643. 

    3644. 

  3644.     //

    3645. 

  3645.     // Access the www.tectite.com website to get the current version.

    3646. 

  3646.     //

    3647. 

  3647. function CheckVersion()

    3648. 

  3648. {

    3649. 

  3649.     global  $FM_VERS;

    3650. 

  3650. 

    3651. 

  3651.     $http_get = new HTTPGet("http://www.tectite.com/fmversion.txt");

    3652. 

  3652.     $php_errormsg = "";     // clear this out in case we get an error that doesn't set it

    3653. 

  3653.     FMDebug("CheckVersion");

    3654. 

  3654.     if (($a_lines = $http_get->Read()) !== false)

    3655. 

  3655.     {

    3656. 

  3656.             //

    3657. 

  3657.             // version file looks like this:

    3658. 

  3658.             //      Version=versionumber

    3659. 

  3659.             //      Message=a message to send in the alert

    3660. 

  3660.             //

    3661. 

  3661.         $s_version = "";

    3662. 

  3662.         $s_message = "";

    3663. 

  3663.         $s_line = "";

    3664. 

  3664.         $b_in_mesg = false;

    3665. 

  3665.         foreach ($a_lines as $s_line)

    3666. 

  3666.         {

    3667. 

  3667.             if ($b_in_mesg)

    3668. 

  3668.                 $s_message .= $s_line;

    3669. 

  3669.             else

    3670. 

  3670.             {

    3671. 

  3671.                 $s_prefix = substr($s_line,0,8);

    3672. 

  3672.                 if ($s_prefix == "Message=")

    3673. 

  3673.                 {

    3674. 

  3674.                     $s_message .= substr($s_line,8);

    3675. 

  3675.                     $b_in_mesg = true;

    3676. 

  3676.                 }

    3677. 

  3677.                 elseif ($s_prefix == "Version=")

    3678. 

  3678.                     $s_version = substr($s_line,8);

    3679. 

  3679.             }

    3680. 

  3680.         }

    3681. 

  3681.         $s_version = str_replace("\r","",$s_version);

    3682. 

  3682.         $s_version = str_replace("\n","",$s_version);

    3683. 

  3683.         $s_stop_mesg = GetMessage(MSG_END_VERS_CHK);

    3684. 

  3684.         FMDebug("CheckVersion: vers=$s_version");

    3685. 

  3685.         if ((float) $s_version > (float) $FM_VERS)

    3686. 

  3686.             SendAlert(GetMessage(MSG_VERS_CHK,array(

    3687. 

  3687.                         "TECTITE"=>"www.tectite.com",

    3688. 

  3688.                         "FM_VERS"=>"$FM_VERS",

    3689. 

  3689.                         "NEWVERS"=>$s_version,

    3690. 

  3690.                         ))."\n$s_message\n$s_stop_mesg",true,true);

    3691. 

  3691.     }

    3692. 

  3692. }

    3693. 

  3693. 

    3694. 

  3694.     //

    3695. 

  3695.     // Check for new FormMail version

    3696. 

  3696.     //

    3697. 

  3697. function Check4Update($s_chk_file,$s_id = "")

    3698. 

  3698. {

    3699. 

  3699.     global  $lNow,$php_errormsg;

    3700. 

  3700. 

    3701. 

  3701. @   $l_last_chk = filemtime($s_chk_file);

    3702. 

  3702.     if ($l_last_chk === false || $lNow - $l_last_chk >= (CHECK_DAYS*24*60*60))

    3703. 

  3703.     {

    3704. 

  3704.         CheckVersion();

    3705. 

  3705.             //

    3706. 

  3706.             // update the check file's time stamp

    3707. 

  3707.             //

    3708. 

  3708.     @   $fp = fopen($s_chk_file,"w");

    3709. 

  3709.         if ($fp !== false)

    3710. 

  3710.         {

    3711. 

  3711.             fwrite($fp,"FormMail version check ".

    3712. 

  3712.                 (empty($s_id) ? "" : "for identifier '$s_id' ").

    3713. 

  3713.                 "at ".date("H:i:s d-M-Y",$lNow)."\n");

    3714. 

  3714.             fclose($fp);

    3715. 

  3715.         }

    3716. 

  3716.         else

    3717. 

  3717.             SendAlert(GetMessage(MSG_CHK_FILE_ERROR,array("FILE"=>$s_chk_file,

    3718. 

  3718.                             "ERROR"=>CheckString($php_errormsg))));

    3719. 

  3719.     }

    3720. 

  3720. }

    3721. 

  3721. 

    3722. 

  3722.     //

    3723. 

  3723.     // Perform various processing at the end of the script's execution.

    3724. 

  3724.     //

    3725. 

  3725. function OnExit()

    3726. 

  3726. {

    3727. 

  3727.     global  $TARGET_EMAIL,$CHECK_FILE;

    3728. 

  3728. 

    3729. 

  3729.     FMDebug("OnExit");

    3730. 

  3730. 

    3731. 

  3731.         //

    3732. 

  3732.         // Check the www.tectite.com website for a new version, but only

    3733. 

  3733.         // do this check once every CHECK_DAYS days (or on server reboot).

    3734. 

  3734.         //

    3735. 

  3735.     if (CHECK_FOR_NEW_VERSION)

    3736. 

  3736.     {

    3737. 

  3737.         global  $SERVER;

    3738. 

  3738. 

    3739. 

  3739.         if (isset($TARGET_EMAIL[0]))

    3740. 

  3740.         {

    3741. 

  3741.                 //

    3742. 

  3742.                 // use the first few characters of the MD5 of first email

    3743. 

  3743.                 // address pattern from $TARGET_EMAIL to get a unique file

    3744. 

  3744.                 // for the server

    3745. 

  3745.                 //

    3746. 

  3746.             $s_id = "";

    3747. 

  3747.             if (isset($SERVER) && !empty($SERVER))

    3748. 

  3748.                 $s_id = $SERVER;

    3749. 

  3749.             $s_dir = GetTempDir();

    3750. 

  3750.             $s_md5 = md5($TARGET_EMAIL[0]);

    3751. 

  3751.             $s_uniq = substr($s_md5,0,6);

    3752. 

  3752.             $s_chk_file = "fm"."$s_uniq".".txt";

    3753. 

  3753.             Check4Update($s_dir."/".$s_chk_file,$s_id);

    3754. 

  3754.         }

    3755. 

  3755.     }

    3756. 

  3756. }

    3757. 

  3757. 

    3758. 

  3758. register_shutdown_function('OnExit');

    3759. 

  3759. 

    3760. 

  3760.     //

    3761. 

  3761.     // Return the array with each string processed by htmlentities

    3762. 

  3762.     //

    3763. 

  3763. function HTMLEntitiesArray($a_array,$b_equals_processing = false,$s_charset = NULL)

    3764. 

  3764. {

    3765. 

  3765.     foreach ($a_array as $m_key=>$s_str)

    3766. 

  3766.     {

    3767. 

  3767.             //

    3768. 

  3768.             // only encode the value after the '='

    3769. 

  3769.             //

    3770. 

  3770.         if ($b_equals_processing && ($i_pos = strpos($s_str,'=')) !== false)

    3771. 

  3771.             $a_array[$m_key] = substr($s_str,0,$i_pos+1).

    3772. 

  3772.                                 FixedHTMLEntities(substr($s_str,$i_pos+1),$s_charset);

    3773. 

  3773.         else

    3774. 

  3774.             $a_array[$m_key] = FixedHTMLEntities($s_str,$s_charset);

    3775. 

  3775.     }

    3776. 

  3776.     return ($a_array);

    3777. 

  3777. }

    3778. 

  3778. 

    3779. 

  3779.     //

    3780. 

  3780.     // Unfortunately, htmlentities (in some versions of PHP) gets

    3781. 

  3781.     // some characters wrong and converts them even when the

    3782. 

  3782.     // charset is provided.

    3783. 

  3783.     // This function overcomes this problem.

    3784. 

  3784.     //

    3785. 

  3785. function    FixedHTMLEntities($s_str,$s_charset = NULL)

    3786. 

  3786. {

    3787. 

  3787.     global  $sHTMLCharSet;

    3788. 

  3788. 

    3789. 

  3789.     if (isset($s_charset) && $s_charset != "")

    3790. 

  3790.         return (htmlspecialchars($s_str,ENT_COMPAT,$s_charset));

    3791. 

  3791.     if (isset($sHTMLCharSet) && $sHTMLCharSet != "")

    3792. 

  3792.         return (htmlspecialchars($s_str,ENT_COMPAT,$sHTMLCharSet));

    3793. 

  3793.     return (htmlentities($s_str));

    3794. 

  3794. }

    3795. 

  3795. 

    3796. 

  3796.     //

    3797. 

  3797.     // Return the array with each string urlencode'd.

    3798. 

  3798.     //

    3799. 

  3799. function URLEncodeArray($a_array)

    3800. 

  3800. {

    3801. 

  3801.     foreach ($a_array as $m_key=>$s_str)

    3802. 

  3802.     {

    3803. 

  3803.             //

    3804. 

  3804.             // only encode the value after the '='

    3805. 

  3805.             //

    3806. 

  3806.         if (($i_pos = strpos($s_str,'=')) !== false)

    3807. 

  3807.             $a_array[$m_key] = substr($s_str,0,$i_pos+1).

    3808. 

  3808.                                 urlencode(substr($s_str,$i_pos+1));

    3809. 

  3809.         else

    3810. 

  3810.             $a_array[$m_key] = urlencode($s_str);

    3811. 

  3811.     }

    3812. 

  3812.     return ($a_array);

    3813. 

  3813. }

    3814. 

  3814. 

    3815. 

  3815.     //

    3816. 

  3816.     // Performs charset encoding for header line text.

    3817. 

  3817.     // This operates according to RFC 2047, but without

    3818. 

  3818.     // imposing the 75 character limit on an encoding.

    3819. 

  3819.     // I haven't implemented that because of all the dramas

    3820. 

  3820.     // with *trying* to obey the header line length rules that

    3821. 

  3821.     // don't seem to work with PHP, the MTA, and email clients.

    3822. 

  3822.     //

    3823. 

  3823. function    EncodeHeaderText($s_text,$i_max_line = -1)

    3824. 

  3824. {

    3825. 

  3825.     global  $sHTMLCharSet;

    3826. 

  3826. 

    3827. 

  3827.         //

    3828. 

  3828.         // RFCLINELEN is the RFC recommended maximum line length, but we don't know

    3829. 

  3829.         // what the front part of the line will be at this point.

    3830. 

  3830.         // So, we'll be conservative and reduce it.

    3831. 

  3831.         //

    3832. 

  3832.     if ($i_max_line == 0)

    3833. 

  3833.         $i_max_line = RFCLINELEN - 15;

    3834. 

  3834.     $s_charset = "";

    3835. 

  3835.     if (isset($sHTMLCharSet) && $sHTMLCharSet != "")

    3836. 

  3836.         $s_charset = $sHTMLCharSet;

    3837. 

  3837.     else if (IsMailOptionSet("CharSet"))

    3838. 

  3838.         $s_charset = GetMailOption("CharSet");

    3839. 

  3839.     if ($s_charset != "")

    3840. 

  3840.     {

    3841. 

  3841.             //

    3842. 

  3842.             // this is the for base64 encoding.

    3843. 

  3843.             // quoted printable is a better choice for human readability

    3844. 

  3844.             //

    3845. 

  3845.         //return ("=?".$s_charset."?B?".base64_encode($s_text)."?=");

    3846. 

  3846.         $s_prefix = "=?".$s_charset."?Q?";

    3847. 

  3847.         $s_suffix = "?=";

    3848. 

  3848.             //

    3849. 

  3849.             // pick a line length that allows a line split with the prefix or suffix added

    3850. 

  3850.             // to be within the RFC maximum recommended line length

    3851. 

  3851.             //

    3852. 

  3852.         return ($s_prefix.QPEncode($s_text,$i_max_line-strlen($s_prefix)).$s_suffix);

    3853. 

  3853.     }

    3854. 

  3854.     else

    3855. 

  3855.         return ($s_text);

    3856. 

  3856. }

    3857. 

  3857. 

    3858. 

  3858.     //

    3859. 

  3859.     // Add a parameter or list of parameters to a URL.

    3860. 

  3860.     //

    3861. 

  3861. function AddURLParams($s_url,$m_params,$b_encode = true)

    3862. 

  3862. {

    3863. 

  3863.     if (!empty($m_params))

    3864. 

  3864.     {

    3865. 

  3865.         if (!is_array($m_params))

    3866. 

  3866.             $m_params = array($m_params);

    3867. 

  3867.         $s_anchor = "";

    3868. 

  3868.         if (($i_pos = strpos($s_url,'#')) !== false)

    3869. 

  3869.         {

    3870. 

  3870.                 //

    3871. 

  3871.                 // extract the anchor

    3872. 

  3872.                 //

    3873. 

  3873.             $s_anchor = substr($s_url,$i_pos);

    3874. 

  3874.             $s_url = substr($s_url,0,$i_pos);

    3875. 

  3875.         }

    3876. 

  3876.         if (strpos($s_url,'?') === false)

    3877. 

  3877.             $s_url .= '?';

    3878. 

  3878.         else

    3879. 

  3879.             $s_url .= '&';

    3880. 

  3880.         $s_url .= implode('&',($b_encode) ? URLEncodeArray($m_params) : $m_params);

    3881. 

  3881.         if ($s_anchor !== "")

    3882. 

  3882.             $s_url .= "$s_anchor";

    3883. 

  3883.     }

    3884. 

  3884.     return ($s_url);

    3885. 

  3885. }

    3886. 

  3886. 

    3887. 

  3887.     //

    3888. 

  3888.     // Recursively trim an array of strings (non string values are converted

    3889. 

  3889.     // to a string first).

    3890. 

  3890.     //

    3891. 

  3891. function TrimArray($a_list)

    3892. 

  3892. {

    3893. 

  3893.     foreach ($a_list as $m_key=>$m_item)

    3894. 

  3894.         if (is_array($m_item))

    3895. 

  3895.             $a_list[$m_key] = TrimArray($m_item);

    3896. 

  3896.         elseif (is_scalar($m_item))

    3897. 

  3897.             $a_list[$m_key] = trim("$m_item");

    3898. 

  3898.         else

    3899. 

  3899.             $a_list[$m_key] = "";

    3900. 

  3900.     return ($a_list);

    3901. 

  3901. }

    3902. 

  3902. 

    3903. 

  3903.     //

    3904. 

  3904.     // Parse a derivation specification and return an array of

    3905. 

  3905.     // field names and operators.

    3906. 

  3906.     //

    3907. 

  3907. function ParseDerivation($a_form_data,$s_fld_spec,$s_name,&$a_errors)

    3908. 

  3908. {

    3909. 

  3909.     $a_deriv = array();

    3910. 

  3910.     while (($i_len = strlen($s_fld_spec)) > 0)

    3911. 

  3911.     {

    3912. 

  3912.             //

    3913. 

  3913.             // we support the following operators:

    3914. 

  3914.             //      +   concatenate with a single space between, but skip the space

    3915. 

  3915.             //          if the next field is empty

    3916. 

  3916.             //      *   concatenate with a single space between

    3917. 

  3917.             //      .   concatenate with no space between

    3918. 

  3918.             //

    3919. 

  3919.         $i_span = strcspn($s_fld_spec,'+*.');

    3920. 

  3920.         if ($i_span == 0)

    3921. 

  3921.         {

    3922. 

  3922.             $a_errors[] = $s_name;

    3923. 

  3923.             return (false);

    3924. 

  3924.         }

    3925. 

  3925.         $a_deriv[] = trim(substr($s_fld_spec,0,$i_span));

    3926. 

  3926.         if ($i_span < $i_len)

    3927. 

  3927.         {

    3928. 

  3928.             $a_deriv[] = substr($s_fld_spec,$i_span,1);

    3929. 

  3929.             $s_fld_spec = substr($s_fld_spec,$i_span+1);

    3930. 

  3930.         }

    3931. 

  3931.         else

    3932. 

  3932.             $s_fld_spec = "";

    3933. 

  3933.     }

    3934. 

  3934.     return ($a_deriv);

    3935. 

  3935. }

    3936. 

  3936. 

    3937. 

  3937.     //

    3938. 

  3938.     // Test if a character is an alphabetic.

    3939. 

  3939.     //

    3940. 

  3940. function IsAlpha($ch)

    3941. 

  3941. {

    3942. 

  3942.     return (strpos("abcdefghijklmnopqrstuvwxyz",strtolower($ch)) !== false);

    3943. 

  3943. }

    3944. 

  3944. 

    3945. 

  3945.     //

    3946. 

  3946.     // Test if a character is a digit.

    3947. 

  3947.     //

    3948. 

  3948. function IsNumeric($ch)

    3949. 

  3949. {

    3950. 

  3950.     return (strpos("0123456789",$ch) !== false);

    3951. 

  3951. }

    3952. 

  3952. 

    3953. 

  3953.     //

    3954. 

  3954.     // Test if a character is an alphanumeric

    3955. 

  3955.     //

    3956. 

  3956. function IsAlnum($ch)

    3957. 

  3957. {

    3958. 

  3958.     return (IsAlpha($ch) || IsNumeric($ch));

    3959. 

  3959. }

    3960. 

  3960. 

    3961. 

  3961.     //

    3962. 

  3962.     // Return an array of tokens extracted from the given string.

    3963. 

  3963.     // A token is:

    3964. 

  3964.     //  - a word (begins with alpha or _, and is followed by any number

    3965. 

  3965.     //    of alphanumerics or _ chars)

    3966. 

  3966.     //  - a number (any number of consecutive digits with up to one period)

    3967. 

  3967.     //  - a string enclosed in specified quotes (this can be disabled)

    3968. 

  3968.     //  - any punctuation character

    3969. 

  3969.     //

    3970. 

  3970.     // Anything not matching the above is silently ignored!

    3971. 

  3971.     //

    3972. 

  3972. function GetTokens($s_str,$s_quotes = "'\"")

    3973. 

  3973. {

    3974. 

  3974.     $b_allow_strings = ($s_quotes !== "") ? true : false;

    3975. 

  3975.     $ii = 0;

    3976. 

  3976.     $i_len = strlen($s_str);

    3977. 

  3977.     $a_toks = array();

    3978. 

  3978. 

    3979. 

  3979.     while ($ii < $i_len)

    3980. 

  3980.     {

    3981. 

  3981.         switch ($ch = $s_str[$ii])

    3982. 

  3982.         {

    3983. 

  3983.         case " ":

    3984. 

  3984.         case "\t":

    3985. 

  3985.         case "\n":

    3986. 

  3986.         case "\r":

    3987. 

  3987.             $ii++;

    3988. 

  3988.             continue;

    3989. 

  3989.         }

    3990. 

  3990.             //

    3991. 

  3991.             // start of a token

    3992. 

  3992.             //

    3993. 

  3993.         $i_start = $ii;

    3994. 

  3994.         if ($ch == "_" || IsAlpha($ch))

    3995. 

  3995.         {

    3996. 

  3996.                 //

    3997. 

  3997.                 // a word

    3998. 

  3998.                 //

    3999. 

  3999.             $i_count = 1;

    4000. 

  4000.             while (++$ii < $i_len &&

    4001. 

  4001.                    ($s_str[$ii] == "_" || IsAlnum($s_str[$ii])))

    4002. 

  4002.                 ++$i_count;

    4003. 

  4003.             $a_toks[] = substr($s_str,$i_start,$i_count);

    4004. 

  4004.         }

    4005. 

  4005.         elseif (($ch == "." && $ii < ($i_len-1) && IsNumeric($s_str[$ii+1]))||

    4006. 

  4006.                 IsNumeric($ch))

    4007. 

  4007.         {

    4008. 

  4008.                 //

    4009. 

  4009.                 // a number

    4010. 

  4010.                 //

    4011. 

  4011.             $b_had_dot = ($ch == ".");

    4012. 

  4012.             $i_count = 1;

    4013. 

  4013.             while (++$ii < $i_len)

    4014. 

  4014.             {

    4015. 

  4015.                 if (IsNumeric($s_str[$ii]))

    4016. 

  4016.                     ++$i_count;

    4017. 

  4017.                 elseif ($s_str[$ii] == "." && !$b_had_dot)

    4018. 

  4018.                 {

    4019. 

  4019.                     ++$i_count;

    4020. 

  4020.                     $b_had_dot = true;

    4021. 

  4021.                 }

    4022. 

  4022.                 else

    4023. 

  4023.                     break;

    4024. 

  4024.             }

    4025. 

  4025.             $a_toks[] = substr($s_str,$i_start,$i_count);

    4026. 

  4026.         }

    4027. 

  4027.         elseif ($b_allow_strings && strpos($s_quotes,$ch) !== false)

    4028. 

  4028.         {

    4029. 

  4029.             $c_quote = $ch;

    4030. 

  4030.                 //

    4031. 

  4031.                 // a quoted string

    4032. 

  4032.                 //

    4033. 

  4033.             while (++$ii < $i_len)

    4034. 

  4034.             {

    4035. 

  4035.                 if ($s_str[$ii] == $c_quote)

    4036. 

  4036.                 {

    4037. 

  4037.                     ++$ii;  // include the terminating quote

    4038. 

  4038.                     break;

    4039. 

  4039.                 }

    4040. 

  4040.             }

    4041. 

  4041.             $a_toks[] = substr($s_str,$i_start,$ii-$i_start);

    4042. 

  4042.         }

    4043. 

  4043.         else

    4044. 

  4044.         {

    4045. 

  4045.             $s_punct = "~!@#$%^&*()-+={}[]|:;<>,.?/`\\";

    4046. 

  4046.             if (!$b_allow_strings)

    4047. 

  4047.                 $s_punct .= "'\"";

    4048. 

  4048.             if (strpos($s_punct,$ch) !== false)

    4049. 

  4049.                 $a_toks[] = $ch;

    4050. 

  4050.             ++$ii;

    4051. 

  4051.         }

    4052. 

  4052.     }

    4053. 

  4053.     return ($a_toks);

    4054. 

  4054. }

    4055. 

  4055. 

    4056. 

  4056.     //

    4057. 

  4057.     // Return the value from a derive_fields specification.

    4058. 

  4058.     // Specifications are in this format:

    4059. 

  4059.     //      %info%

    4060. 

  4060.     // where info is a predefined word or a literal in quotes

    4061. 

  4061.     // (e.g. 'the time is ')

    4062. 

  4062.     //

    4063. 

  4063. function ValueSpec($s_spec,$a_form_data,&$a_errors)

    4064. 

  4064. {

    4065. 

  4065.     global  $lNow;

    4066. 

  4066. 

    4067. 

  4067.     $s_value = "";

    4068. 

  4068.     switch (trim($s_spec))

    4069. 

  4069.     {

    4070. 

  4070.     case 'date':        // "standard" date format: DD-MMM-YYYY

    4071. 

  4071.         $s_value = date('d-M-Y',$lNow);

    4072. 

  4072.         break;

    4073. 

  4073.     case 'time':        // "standard" time format: HH:MM:SS

    4074. 

  4074.         $s_value = date('H:i:s',$lNow);

    4075. 

  4075.         break;

    4076. 

  4076.     case 'ampm':        // am or pm

    4077. 

  4077.         $s_value = date('a',$lNow);

    4078. 

  4078.         break;

    4079. 

  4079.     case 'AMPM':        // AM or PM

    4080. 

  4080.         $s_value = date('A',$lNow);

    4081. 

  4081.         break;

    4082. 

  4082.     case 'dom0':        // day of month with possible leading zero

    4083. 

  4083.         $s_value = date('d',$lNow);

    4084. 

  4084.         break;

    4085. 

  4085.     case 'dom':         // day of month with no leading zero

    4086. 

  4086.         $s_value = date('j',$lNow);

    4087. 

  4087.         break;

    4088. 

  4088.     case 'day':         // day name (abbreviated)

    4089. 

  4089.         $s_value = date('D',$lNow);

    4090. 

  4090.         break;

    4091. 

  4091.     case 'dayname':     // day name (full)

    4092. 

  4092.         $s_value = date('l',$lNow);

    4093. 

  4093.         break;

    4094. 

  4094.     case 'daysuffix':   // day number suffix for English (st for 1st, nd for 2nd, etc.)

    4095. 

  4095.         $s_value = date('S',$lNow);

    4096. 

  4096.         break;

    4097. 

  4097.     case 'moy0':        // month of year with possible leading zero

    4098. 

  4098.         $s_value = date('m',$lNow);

    4099. 

  4099.         break;

    4100. 

  4100.     case 'moy':         // month of year with no leading zero

    4101. 

  4101.         $s_value = date('n',$lNow);

    4102. 

  4102.         break;

    4103. 

  4103.     case 'month':       // month name (abbreviated)

    4104. 

  4104.         $s_value = date('M',$lNow);

    4105. 

  4105.         break;

    4106. 

  4106.     case 'monthname':   // month name (full)

    4107. 

  4107.         $s_value = date('F',$lNow);

    4108. 

  4108.         break;

    4109. 

  4109.     case 'year':        // year (two digits)

    4110. 

  4110.         $s_value = date('y',$lNow);

    4111. 

  4111.         break;

    4112. 

  4112.     case 'fullyear':    // year (full)

    4113. 

  4113.         $s_value = date('Y',$lNow);

    4114. 

  4114.         break;

    4115. 

  4115.     case 'rfcdate':     // date formatted according to RFC 822

    4116. 

  4116.         $s_value = date('r',$lNow);

    4117. 

  4117.         break;

    4118. 

  4118.     case 'tzname':      // timezone name

    4119. 

  4119.         $s_value = date('T',$lNow);

    4120. 

  4120.         break;

    4121. 

  4121.     case 'tz':          // timezone difference from Greenwich +NNNN or -NNNN

    4122. 

  4122.         $s_value = date('O',$lNow);

    4123. 

  4123.         break;

    4124. 

  4124.     case 'hour120':     // hour of day (01-12) with possible leading zero

    4125. 

  4125.         $s_value = date('h',$lNow);

    4126. 

  4126.         break;

    4127. 

  4127.     case 'hour240':     // hour of day (00-23) with possible leading zero

    4128. 

  4128.         $s_value = date('H',$lNow);

    4129. 

  4129.         break;

    4130. 

  4130.     case 'hour12':      // hour of day (1-12) with no leading zero

    4131. 

  4131.         $s_value = date('g',$lNow);

    4132. 

  4132.         break;

    4133. 

  4133.     case 'hour24':      // hour of day (0-23) with no leading zero

    4134. 

  4134.         $s_value = date('G',$lNow);

    4135. 

  4135.         break;

    4136. 

  4136.     case 'min':         // minute of hour (00-59)

    4137. 

  4137.         $s_value = date('i',$lNow);

    4138. 

  4138.         break;

    4139. 

  4139.     case 'sec':         // seconds of minute (00-59)

    4140. 

  4140.         $s_value = date('s',$lNow);

    4141. 

  4141.         break;

    4142. 

  4142.     default:

    4143. 

  4143.         if ($s_spec[0] == "'")

    4144. 

  4144.         {

    4145. 

  4145.                 //

    4146. 

  4146.                 // to get a quote, use 3 quotes:

    4147. 

  4147.                 //      '''

    4148. 

  4148.                 //

    4149. 

  4149.             if ($s_spec == "'''")

    4150. 

  4150.                 $s_value = "'";

    4151. 

  4151.             elseif (substr($s_spec,-1,1) == "'")

    4152. 

  4152.                 $s_value = substr($s_spec,1,-1);

    4153. 

  4153.             else

    4154. 

  4154.                     //

    4155. 

  4155.                     // missing final quote is OK

    4156. 

  4156.                     //

    4157. 

  4157.                 $s_value = substr($s_spec,1);

    4158. 

  4158.         }

    4159. 

  4159.         elseif (strspn($s_spec,"0123456789ABCDEF") == 2)

    4160. 

  4160.         {

    4161. 

  4161.                 //

    4162. 

  4162.                 // insert the ASCII character corresponding to

    4163. 

  4163.                 // the hexadecimal value

    4164. 

  4164.                 //

    4165. 

  4165.             $i_val = intval(substr($s_spec,0,2),16);

    4166. 

  4166.             $s_value = chr($i_val);

    4167. 

  4167.         }

    4168. 

  4168.         else

    4169. 

  4169.         {

    4170. 

  4170.                 //

    4171. 

  4171.                 // look for supported functions, start by getting all

    4172. 

  4172.                 // the tokens

    4173. 

  4173.                 //

    4174. 

  4174.             $a_toks = GetTokens($s_spec);

    4175. 

  4175.             if (count($a_toks) > 0)

    4176. 

  4176.             {

    4177. 

  4177.                 switch ($a_toks[0])

    4178. 

  4178.                 {

    4179. 

  4179.                 case "if":

    4180. 

  4180.                         //

    4181. 

  4181.                         // "if" function: test first field

    4182. 

  4182.                         //       if not empty, then use second field

    4183. 

  4183.                         //       else, use third field

    4184. 

  4184.                         //

    4185. 

  4185.                         // Example: if(fld1 ; fld2 ; fld3)

    4186. 

  4186.                         //

    4187. 

  4187.                         // tokens are:

    4188. 

  4188.                         //      1               (

    4189. 

  4189.                         //      2               the field name to test (first)

    4190. 

  4190.                         //      3               ;

    4191. 

  4191.                         //      4               the "then" spec (can be missing)

    4192. 

  4192.                         //      5               ;

    4193. 

  4193.                         //      6               the "else" spec (can be missing)

    4194. 

  4194.                         //      7               )

    4195. 

  4195.                         //

    4196. 

  4196.                     if (($n_tok = count($a_toks)) < 6 ||

    4197. 

  4197.                             $a_toks[1] != "(" ||

    4198. 

  4198.                             $a_toks[3] != ";" ||

    4199. 

  4199.                             $a_toks[$n_tok-1] != ")")

    4200. 

  4200.                         SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4201. 

  4201.                                         array("SPEC"=>$s_spec,

    4202. 

  4202.                                               "MSG"=>GetMessage(MSG_DER_FUNC_IF_FMT))));

    4203. 

  4203.                     else

    4204. 

  4204.                     {

    4205. 

  4205.                         $b_ok = true;

    4206. 

  4206.                         $s_fld_name = $a_toks[2];

    4207. 

  4207.                         $s_then_spec = $s_else_spec = "";

    4208. 

  4208.                         for ($ii = 4 ; $ii < $n_tok && $a_toks[$ii] != ';' ; $ii++)

    4209. 

  4209.                             $s_then_spec .= $a_toks[$ii];

    4210. 

  4210.                         if ($ii == $n_tok)

    4211. 

  4211.                             $b_ok = false;

    4212. 

  4212.                         else

    4213. 

  4213.                         {

    4214. 

  4214.                                 //

    4215. 

  4215.                                 // Concatenate tokens until the ')'.

    4216. 

  4216.                                 // This provides the "else" spec.

    4217. 

  4217.                                 //

    4218. 

  4218.                             for ( ; ++$ii < $n_tok && $a_toks[$ii] != ')' ; )

    4219. 

  4219.                                 $s_else_spec .= $a_toks[$ii];

    4220. 

  4220.                             if ($ii == $n_tok)

    4221. 

  4221.                                 $b_ok = false;

    4222. 

  4222.                         }

    4223. 

  4223.                         if ($b_ok)

    4224. 

  4224.                         {

    4225. 

  4225.                             if (!TestFieldEmpty($s_fld_name,$a_form_data,$s_mesg))

    4226. 

  4226.                                 $s_fld_spec = $s_then_spec;

    4227. 

  4227.                             else

    4228. 

  4228.                                 $s_fld_spec = $s_else_spec;

    4229. 

  4229.                             $s_value = GetDerivedValue($a_form_data,$s_fld_spec,$a_errors);

    4230. 

  4230.                         }

    4231. 

  4231.                         else

    4232. 

  4232.                             SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4233. 

  4233.                                             array("SPEC"=>$s_spec,

    4234. 

  4234.                                                   "MSG"=>GetMessage(MSG_DER_FUNC_IF_FMT))));

    4235. 

  4235.                     }

    4236. 

  4236.                     break;

    4237. 

  4237.                 case "size":

    4238. 

  4238.                         //

    4239. 

  4239.                         // "size" function: return size of uploaded file

    4240. 

  4240.                         //

    4241. 

  4241.                         // Example: size(fieldname)

    4242. 

  4242.                         //

    4243. 

  4243.                         // tokens are:

    4244. 

  4244.                         //      1               (

    4245. 

  4245.                         //      2               the field name for the file upload

    4246. 

  4246.                         //      3               )

    4247. 

  4247.                         //

    4248. 

  4248.                     if (count($a_toks) != 4 ||

    4249. 

  4249.                             $a_toks[1] != "(" ||

    4250. 

  4250.                             $a_toks[3] != ")")

    4251. 

  4251.                         SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4252. 

  4252.                                         array("SPEC"=>$s_spec,

    4253. 

  4253.                                               "MSG"=>GetMessage(MSG_DER_FUNC_SIZE_FMT))));

    4254. 

  4254.                     elseif (($i_size = GetFileSize($a_toks[2])) !== false)

    4255. 

  4255.                         $s_value = "$i_size";

    4256. 

  4256.                     break;

    4257. 

  4257.                 case "ext":

    4258. 

  4258.                         //

    4259. 

  4259.                         // "ext" function: return filename extension of uploaded file

    4260. 

  4260.                         //

    4261. 

  4261.                         // Example: ext(fieldname)

    4262. 

  4262.                         //

    4263. 

  4263.                         // tokens are:

    4264. 

  4264.                         //      1               (

    4265. 

  4265.                         //      2               the field name for the file upload

    4266. 

  4266.                         //      3               )

    4267. 

  4267.                         //

    4268. 

  4268.                     if (count($a_toks) != 4 ||

    4269. 

  4269.                             $a_toks[1] != "(" ||

    4270. 

  4270.                             $a_toks[3] != ")")

    4271. 

  4271.                         SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4272. 

  4272.                                         array("SPEC"=>$s_spec,

    4273. 

  4273.                                               "MSG"=>GetMessage(MSG_DER_FUNC_EXT_FMT))));

    4274. 

  4274.                     elseif (($s_name = GetFileName($a_toks[2])) !== false)

    4275. 

  4275.                     {

    4276. 

  4276.                         if (($i_pos = strrpos($s_name,".")) !== false)

    4277. 

  4277.                             $s_value = substr($s_name,$i_pos+1);

    4278. 

  4278.                     }

    4279. 

  4279.                     break;

    4280. 

  4280.                 case "ucase":

    4281. 

  4281.                 case "lcase":

    4282. 

  4282.                         //

    4283. 

  4283.                         // "ucase" and "lcase" functions: return field

    4284. 

  4284.                         // converted to upper or lower case

    4285. 

  4285.                         //

    4286. 

  4286.                         // Example: lcase(fieldname)

    4287. 

  4287.                         //

    4288. 

  4288.                         // tokens are:

    4289. 

  4289.                         //      1               (

    4290. 

  4290.                         //      2               the field name to convert

    4291. 

  4291.                         //      3               )

    4292. 

  4292.                         //

    4293. 

  4293.                     if (count($a_toks) != 4 ||

    4294. 

  4294.                             $a_toks[1] != "(" ||

    4295. 

  4295.                             $a_toks[3] != ")")

    4296. 

  4296.                         SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4297. 

  4297.                                         array("SPEC"=>$s_spec,

    4298. 

  4298.                                               "MSG"=>GetMessage(MSG_DER_FUNC1_FMT,

    4299. 

  4299.                                                     array("FUNC"=>$a_toks[0])))));

    4300. 

  4300.                     elseif ($a_toks[0] == "ucase")

    4301. 

  4301.                         $s_value = strtoupper(GetFieldValue($a_toks[2],$a_form_data));

    4302. 

  4302.                     else

    4303. 

  4303.                         $s_value = strtolower(GetFieldValue($a_toks[2],$a_form_data));

    4304. 

  4304.                     break;

    4305. 

  4305.                 case "ltrim":

    4306. 

  4306.                 case "rtrim":

    4307. 

  4307.                 case "trim":

    4308. 

  4308.                         //

    4309. 

  4309.                         // trim functions: return field with whitespace removed

    4310. 

  4310.                         // from left (ltrim), right (rtrim), or both (trim)

    4311. 

  4311.                         // ends.

    4312. 

  4312.                         //

    4313. 

  4313.                         // Example: ltrim(fieldname)

    4314. 

  4314.                         //

    4315. 

  4315.                         // tokens are:

    4316. 

  4316.                         //      1               (

    4317. 

  4317.                         //      2               the field name to trim

    4318. 

  4318.                         //      3               )

    4319. 

  4319.                         //

    4320. 

  4320.                     if (count($a_toks) != 4 ||

    4321. 

  4321.                             $a_toks[1] != "(" ||

    4322. 

  4322.                             $a_toks[3] != ")")

    4323. 

  4323.                         SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4324. 

  4324.                                         array("SPEC"=>$s_spec,

    4325. 

  4325.                                               "MSG"=>GetMessage(MSG_DER_FUNC1_FMT,

    4326. 

  4326.                                               array("FUNC"=>$a_toks[0])))));

    4327. 

  4327.                     else

    4328. 

  4328.                         $s_value = $a_toks[0](GetFieldValue($a_toks[2],$a_form_data));

    4329. 

  4329.                     break;

    4330. 

  4330.                 case "ltrim0":

    4331. 

  4331.                         //

    4332. 

  4332.                         // ltrim0 function: return field with blanks and

    4333. 

  4333.                         // leading 0's removed from the left.

    4334. 

  4334.                         //

    4335. 

  4335.                         // Example: ltrim0(fieldname)

    4336. 

  4336.                         //

    4337. 

  4337.                         // tokens are:

    4338. 

  4338.                         //      1               (

    4339. 

  4339.                         //      2               the field name to trim

    4340. 

  4340.                         //      3               )

    4341. 

  4341.                         //

    4342. 

  4342.                     if (count($a_toks) != 4 ||

    4343. 

  4343.                             $a_toks[1] != "(" ||

    4344. 

  4344.                             $a_toks[3] != ")")

    4345. 

  4345.                         SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4346. 

  4346.                                         array("SPEC"=>$s_spec,

    4347. 

  4347.                                               "MSG"=>GetMessage(MSG_DER_FUNC1_FMT,

    4348. 

  4348.                                               array("FUNC"=>$a_toks[0])))));

    4349. 

  4349.                     else

    4350. 

  4350.                     {

    4351. 

  4351.                         $s_value = GetFieldValue($a_toks[2],$a_form_data);

    4352. 

  4352.                         $s_value = ltrim($s_value);     // trim blanks on left

    4353. 

  4353.                         $i_len = strspn($s_value,"0");

    4354. 

  4354.                             //

    4355. 

  4355.                             // if the whole string is zeroes, make sure we leave

    4356. 

  4356.                             // one of them!

    4357. 

  4357.                             //

    4358. 

  4358.                         if ($i_len == strlen($s_value))

    4359. 

  4359.                             if (--$i_len < 0)

    4360. 

  4360.                                 $i_len = 0;

    4361. 

  4361.                         $s_value = substr($s_value,$i_len);

    4362. 

  4362.                     }

    4363. 

  4363.                     break;

    4364. 

  4364.                 case "nextnum":

    4365. 

  4365.                         //

    4366. 

  4366.                         // "nextnum" function: return a unique number (next number)

    4367. 

  4367.                         //

    4368. 

  4368.                         // Usage: nextnum[(pad[,base])]

    4369. 

  4369.                         //

    4370. 

  4370.                         // Examples:

    4371. 

  4371.                         //      %nextnum%

    4372. 

  4372.                         //      %nextnum(8)%

    4373. 

  4373.                         //      %nextnum(5;16)%

    4374. 

  4374.                         //

    4375. 

  4375.                         // You can provide a padding amount. In this case, the

    4376. 

  4376.                         // number is padded on the left with zeroes to the number

    4377. 

  4377.                         // of digits specified.

    4378. 

  4378.                         //

    4379. 

  4379.                         // You can also provide a base for your numbers.  Valid

    4380. 

  4380.                         // values for base are 2 to 36, inclusive.

    4381. 

  4381.                         //

    4382. 

  4382.                         // tokens are:

    4383. 

  4383.                         //      1               (

    4384. 

  4384.                         //      2               the padding amount

    4385. 

  4385.                         //      3               ;

    4386. 

  4386.                         //      4               the base

    4387. 

  4387.                         //      5               )

    4388. 

  4388.                         //

    4389. 

  4389.                     $i_pad = 0;     // no padding

    4390. 

  4390.                     $i_base = 10;   // base 10

    4391. 

  4391.                     if (($n_tok = count($a_toks)) > 1)

    4392. 

  4392.                     {

    4393. 

  4393.                         if (($n_tok != 4 && $n_tok != 6) ||

    4394. 

  4394.                             $a_toks[1] != "(" ||

    4395. 

  4395.                             $a_toks[$n_tok-1] != ")")

    4396. 

  4396.                             SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4397. 

  4397.                                         array("SPEC"=>$s_spec,

    4398. 

  4398.                                               "MSG"=>GetMessage(MSG_DER_FUNC_NEXTNUM_FMT)." (T1)")));

    4399. 

  4399.                         if ($n_tok == 6 && $a_toks[3] != ";")

    4400. 

  4400.                             SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4401. 

  4401.                                         array("SPEC"=>$s_spec,

    4402. 

  4402.                                               "MSG"=>GetMessage(MSG_DER_FUNC_NEXTNUM_FMT)." (T2)")));

    4403. 

  4403.                         if (!is_numeric($a_toks[2]) ||

    4404. 

  4404.                             ($n_tok == 6 && !is_numeric($a_toks[4])))

    4405. 

  4405.                             SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4406. 

  4406.                                         array("SPEC"=>$s_spec,

    4407. 

  4407.                                               "MSG"=>GetMessage(MSG_DER_FUNC_NEXTNUM_FMT)." (T3)")));

    4408. 

  4408.                         $i_pad = intval($a_toks[2]);

    4409. 

  4409.                         if ($n_tok == 6)

    4410. 

  4410.                         {

    4411. 

  4411.                             $i_base = intval($a_toks[4]);

    4412. 

  4412.                             if ($i_base < 2 || $i_base > 36)

    4413. 

  4413.                             {

    4414. 

  4414.                                 SendAlert(GetMessage(MSG_DER_FUNC_ERROR,

    4415. 

  4415.                                             array("SPEC"=>$s_spec,

    4416. 

  4416.                                                   "MSG"=>GetMessage(MSG_DER_FUNC_NEXTNUM_FMT)." (T4)")));

    4417. 

  4417.                                 $i_base = 10;

    4418. 

  4418.                             }

    4419. 

  4419.                         }

    4420. 

  4420.                         $s_value = GetNextNum($i_pad,$i_base);

    4421. 

  4421.                     }

    4422. 

  4422.                     else

    4423. 

  4423.                     {

    4424. 

  4424.                         $s_value = GetNextNum($i_pad,$i_base);

    4425. 

  4425.                     }

    4426. 

  4426.                     break;

    4427. 

  4427.                 default:

    4428. 

  4428.                     SendAlert(GetMessage(MSG_UNK_VALUE_SPEC,

    4429. 

  4429.                                     array("SPEC"=>$s_spec,"MSG"=>"")));

    4430. 

  4430.                     break;

    4431. 

  4431.                 }

    4432. 

  4432.             }

    4433. 

  4433.             else

    4434. 

  4434.                 SendAlert(GetMessage(MSG_UNK_VALUE_SPEC,array("SPEC"=>$s_spec,

    4435. 

  4435.                                                             "MSG"=>"")));

    4436. 

  4436.         }

    4437. 

  4437.         break;

    4438. 

  4438.     }

    4439. 

  4439.     return ($s_value);

    4440. 

  4440. }

    4441. 

  4441. 

    4442. 

  4442.     //

    4443. 

  4443.     // Return the next number or fail on error

    4444. 

  4444.     //

    4445. 

  4445. function GetNextNum($i_pad,$i_base)

    4446. 

  4446. {

    4447. 

  4447.     global  $NEXT_NUM_FILE,$php_errormsg;

    4448. 

  4448. 

    4449. 

  4449.     if (!isset($NEXT_NUM_FILE) || $NEXT_NUM_FILE === "")

    4450. 

  4450.     {

    4451. 

  4451.         ErrorWithIgnore("next_num_config",GetMessage(MSG_NO_NEXT_NUM_FILE));

    4452. 

  4452.         exit;

    4453. 

  4453.     }

    4454. 

  4454.     if (($fp = @fopen($NEXT_NUM_FILE,"r+")) === false)

    4455. 

  4455.     {

    4456. 

  4456.         Error("next_num_file",GetMessage(MSG_NEXT_NUM_FILE,

    4457. 

  4457.                                     array("FILE"=>$NEXT_NUM_FILE,

    4458. 

  4458.                                         "ACT"=>"open",

    4459. 

  4459.                                         "ERR"=>$php_errormsg)));

    4460. 

  4460.         exit;

    4461. 

  4461.     }

    4462. 

  4462.     if (!flock($fp,defined("LOCK_EX") ? LOCK_EX : 2))

    4463. 

  4463.     {

    4464. 

  4464.         Error("next_num_file",GetMessage(MSG_NEXT_NUM_FILE,

    4465. 

  4465.                                     array("FILE"=>$NEXT_NUM_FILE,

    4466. 

  4466.                                         "ACT"=>"flock",

    4467. 

  4467.                                         "ERR"=>$php_errormsg)));

    4468. 

  4468.         exit;

    4469. 

  4469.     }

    4470. 

  4470.         //

    4471. 

  4471.         // read the first line only

    4472. 

  4472.         //

    4473. 

  4473.     if (!feof($fp))

    4474. 

  4474.     {

    4475. 

  4475.         if (($s_line = fread($fp,1024)) === false)

    4476. 

  4476.             $i_next = 1;

    4477. 

  4477.         elseif (($i_next = intval($s_line)) <= 0)

    4478. 

  4478.             $i_next = 1;

    4479. 

  4479.     }

    4480. 

  4480.     else

    4481. 

  4481.         $i_next = 1;

    4482. 

  4482.     if (rewind($fp) == 0)

    4483. 

  4483.     {

    4484. 

  4484.         Error("next_num_file",GetMessage(MSG_NEXT_NUM_FILE,

    4485. 

  4485.                                     array("FILE"=>$NEXT_NUM_FILE,

    4486. 

  4486.                                         "ACT"=>"rewind",

    4487. 

  4487.                                         "ERR"=>$php_errormsg)));

    4488. 

  4488.         exit;

    4489. 

  4489.     }

    4490. 

  4490.     $s_ret = strval($i_next++);

    4491. 

  4491.     if (fputs($fp,"$i_next\r\n") <= 0)

    4492. 

  4492.     {

    4493. 

  4493.         Error("next_num_file",GetMessage(MSG_NEXT_NUM_FILE,

    4494. 

  4494.                                     array("FILE"=>$NEXT_NUM_FILE,

    4495. 

  4495.                                         "ACT"=>"fputs",

    4496. 

  4496.                                         "ERR"=>$php_errormsg)));

    4497. 

  4497.         exit;

    4498. 

  4498.     }

    4499. 

  4499.     fclose($fp);

    4500. 

  4500.     if ($i_base != 10)

    4501. 

  4501.     {

    4502. 

  4502.         $s_ret = base_convert($s_ret,10,$i_base);

    4503. 

  4503.         $s_ret = strtoupper($s_ret);    // always upper case if alphas are used

    4504. 

  4504.     }

    4505. 

  4505.     if ($i_pad != 0)

    4506. 

  4506.         $s_ret = str_pad($s_ret,$i_pad,"0",STR_PAD_LEFT);

    4507. 

  4507.     return ($s_ret);

    4508. 

  4508. }

    4509. 

  4509. 

    4510. 

  4510.     //

    4511. 

  4511.     // Return the value of an object or array as a string.

    4512. 

  4512.     //

    4513. 

  4513. function GetObjectAsString($m_value)

    4514. 

  4514. {

    4515. 

  4515.     ob_start();

    4516. 

  4516.     print_r($m_value);

    4517. 

  4517.     $s_ret = ob_get_contents();

    4518. 

  4518.     ob_end_clean();

    4519. 

  4519.     return ($s_ret);

    4520. 

  4520. }

    4521. 

  4521. 

    4522. 

  4522.     //

    4523. 

  4523.     // Return a Server or Environment variable value.  Returns false if

    4524. 

  4524.     // not found, otherwise a string value.

    4525. 

  4525.     //

    4526. 

  4526. function GetEnvValue($s_name)

    4527. 

  4527. {

    4528. 

  4528.     global  $aServerVars,$aEnvVars;

    4529. 

  4529. 

    4530. 

  4530.     if (isset($aEnvVars[$s_name]))

    4531. 

  4531.         $m_value = $aEnvVars[$s_name];

    4532. 

  4532.     elseif (isset($aServerVars[$s_name]))

    4533. 

  4533.         $m_value = $aServerVars[$s_name];

    4534. 

  4534.         //

    4535. 

  4535.         // some values might not be strings - so convert

    4536. 

  4536.         //

    4537. 

  4537.     if (isset($m_value) && !is_scalar($m_value))

    4538. 

  4538.         $m_value = GetObjectAsString($m_value);

    4539. 

  4539.     return (isset($m_value) ? ((string) $m_value) : false);

    4540. 

  4540. }

    4541. 

  4541. 

    4542. 

  4542.     //

    4543. 

  4543.     // Test if a field is set in the given vars array or in the uploaded

    4544. 

  4544.     // files.

    4545. 

  4545.     //

    4546. 

  4546. function IsFieldSet($s_fld,$a_main_vars)

    4547. 

  4547. {

    4548. 

  4548.     global  $aFileVars;

    4549. 

  4549. 

    4550. 

  4550.     if (isset($a_main_vars[$s_fld]))

    4551. 

  4551.         return (true);

    4552. 

  4552.     if (FILEUPLOADS)

    4553. 

  4553.     {

    4554. 

  4554.         if (isset($aFileVars[$s_fld]))

    4555. 

  4555.             return (true);

    4556. 

  4556.         if (IsSetSession("FormSavedFiles"))

    4557. 

  4557.         {

    4558. 

  4558.             $a_saved_files = GetSession("FormSavedFiles");

    4559. 

  4559.             if (isset($a_saved_files[$s_fld]))

    4560. 

  4560.                 return (true);

    4561. 

  4561.         }

    4562. 

  4562.     }

    4563. 

  4563.     return (false);

    4564. 

  4564. }

    4565. 

  4565. 

    4566. 

  4566. /*

    4567. 

  4567.  * Function:    IsFileField

    4568. 

  4568.  * Parameters:  $s_fld  the field name

    4569. 

  4569.  * Returns:     bool    true if this is a file upload field

    4570. 

  4570.  * Description:     

    4571. 

  4571.  *  Checks if a field is a file upload field (regardless of whether

    4572. 

  4572.  *  file uploads are being allowed, or whether the actual upload

    4573. 

  4573.  *  is valid in any way).

    4574. 

  4574.  */

    4575. 

  4575. function    IsFileField($s_fld)

    4576. 

  4576. {

    4577. 

  4577.     global  $aFileVars;

    4578. 

  4578.     

    4579. 

  4579.     return (isset($aFileVars[$s_fld]));

    4580. 

  4580. }

    4581. 

  4581. 

    4582. 

  4582.     //

    4583. 

  4583.     // Delete the info for an uploaded file

    4584. 

  4584.     //

    4585. 

  4585. function DeleteFileInfo($s_fld)

    4586. 

  4586. {

    4587. 

  4587.     global  $aFileVars;

    4588. 

  4588.     global  $aCleanedValues,$aRawDataValues,$aAllRawValues;

    4589. 

  4589. 

    4590. 

  4590.     if (FILEUPLOADS)

    4591. 

  4591.     {

    4592. 

  4592.         if (IsSetSession("FormSavedFiles"))

    4593. 

  4593.         {

    4594. 

  4594.             $a_saved_files = GetSession("FormSavedFiles");

    4595. 

  4595.             unset($a_saved_files[$s_fld]);

    4596. 

  4596.             SetSession("FormSavedFiles",$a_saved_files);

    4597. 

  4597.         }

    4598. 

  4598.         if (isset($aFileVars[$s_fld]))

    4599. 

  4599.             unset($aFileVars[$s_fld]);

    4600. 

  4600.             //

    4601. 

  4601.             // zap any "name_of" field that has been created

    4602. 

  4602.             //

    4603. 

  4603.         $s_name = "name_of_$s_fld";

    4604. 

  4604.         unset($aCleanedValues[$s_name]);

    4605. 

  4605.         unset($aRawDataValues[$s_name]);

    4606. 

  4606.         unset($aAllRawValues[$s_name]);

    4607. 

  4607.     }

    4608. 

  4608. }

    4609. 

  4609. 

    4610. 

  4610.     //

    4611. 

  4611.     // Return the info for the uploaded file, or false on error.

    4612. 

  4612.     //

    4613. 

  4613. function GetFileInfo($s_fld)

    4614. 

  4614. {

    4615. 

  4615.     global  $aFileVars;

    4616. 

  4616. 

    4617. 

  4617.     if (FILEUPLOADS)

    4618. 

  4618.     {

    4619. 

  4619.             //

    4620. 

  4620.             // Must look at new file uploads first.

    4621. 

  4621.             //

    4622. 

  4622.         if (isset($aFileVars[$s_fld]) && !empty($aFileVars[$s_fld]))

    4623. 

  4623.             $a_upload = $aFileVars[$s_fld];

    4624. 

  4624.         elseif (IsSetSession("FormSavedFiles"))

    4625. 

  4625.         {

    4626. 

  4626.             $a_saved_files = GetSession("FormSavedFiles");

    4627. 

  4627.             if (isset($a_saved_files[$s_fld]))

    4628. 

  4628.                 $a_upload = $a_saved_files[$s_fld];

    4629. 

  4629.         }

    4630. 

  4630.     }

    4631. 

  4631.     if (isset($a_upload))

    4632. 

  4632.     {

    4633. 

  4633.         if (isset($a_upload["tmp_name"]) && !empty($a_upload["tmp_name"]) &&

    4634. 

  4634.             isset($a_upload["name"]) && !empty($a_upload["name"]) &&

    4635. 

  4635.             IsUploadedFile($a_upload))

    4636. 

  4636.                 return ($a_upload);

    4637. 

  4637.     }

    4638. 

  4638.     return (false);

    4639. 

  4639. }

    4640. 

  4640. 

    4641. 

  4641.     //

    4642. 

  4642.     // Return the original name of the uploaded file or false on error.

    4643. 

  4643.     //

    4644. 

  4644. function GetFileName($s_fld)

    4645. 

  4645. {

    4646. 

  4646.     if (($a_upload = GetFileInfo($s_fld)) !== false)

    4647. 

  4647.         return ($a_upload["name"]);

    4648. 

  4648.     return (false);

    4649. 

  4649. }

    4650. 

  4650. 

    4651. 

  4651.     //

    4652. 

  4652.     // Return the size of the uploaded file or false on error.

    4653. 

  4653.     //

    4654. 

  4654. function GetFileSize($s_fld)

    4655. 

  4655. {

    4656. 

  4656.     if (($a_upload = GetFileInfo($s_fld)) !== false)

    4657. 

  4657.         return ($a_upload["size"]);

    4658. 

  4658.     return (false);

    4659. 

  4659. }

    4660. 

  4660. 

    4661. 

  4661.     //

    4662. 

  4662.     // Return a field value.  Empty string is returned if the field is

    4663. 

  4663.     // not found. File fields return the original name of the uploaded file.

    4664. 

  4664.     //

    4665. 

  4665. function GetFieldValue($s_fld,$a_main_vars,$s_array_sep = ";")

    4666. 

  4666. {

    4667. 

  4667.     if (!isset($a_main_vars[$s_fld]))

    4668. 

  4668.     {

    4669. 

  4669.         if (($s_name = GetFileName($s_fld)) === false)

    4670. 

  4670.             $s_name = "";

    4671. 

  4671.         return ($s_name);

    4672. 

  4672.     }

    4673. 

  4673.     if (is_array($a_main_vars[$s_fld]))

    4674. 

  4674.         return (implode($s_array_sep,$a_main_vars[$s_fld]));

    4675. 

  4675.     else

    4676. 

  4676.         return ((string) $a_main_vars[$s_fld]);

    4677. 

  4677. }

    4678. 

  4678. 

    4679. 

  4679.     //

    4680. 

  4680.     // Tests a field against an array of vars for emptyness.

    4681. 

  4681.     // If the var isn't found there, then the POSTed files array is checked.

    4682. 

  4682.     // Returns true if the field is empty (a specific error may

    4683. 

  4683.     // be returned in the $s_mesg parameter).

    4684. 

  4684.     //

    4685. 

  4685. function TestFieldEmpty($s_fld,$a_main_vars,&$s_mesg)

    4686. 

  4686. {

    4687. 

  4687.     global  $aFileVars;

    4688. 

  4688. 

    4689. 

  4689.     $s_mesg = "";

    4690. 

  4690.     $b_empty = TRUE;

    4691. 

  4691.     if (!isset($a_main_vars[$s_fld]))

    4692. 

  4692.     {

    4693. 

  4693.             //

    4694. 

  4694.             // Each file var is an array with these elements:

    4695. 

  4695.             //      "name" => The original name of the file on the client machine.

    4696. 

  4696.             //      "type" => The mime type of the file, if the browser provided this information.

    4697. 

  4697.             //      "tmp_name" => The temporary filename of the file in which the uploaded file was stored on the server.

    4698. 

  4698.             //      "error" => The error code associated with this file upload.

    4699. 

  4699.             //                  NOTE: "error" was added in PHP 4.2.0

    4700. 

  4700.             //      "size" => The size, in bytes, of the uploaded file.

    4701. 

  4701.             //

    4702. 

  4702.             // Error codes (the constants are only available from PHP 4.3.0 so

    4703. 

  4703.             // we have to use the raw numbers):

    4704. 

  4704.             //  UPLOAD_ERR_OK

    4705. 

  4705.             //      Value: 0; There is no error, the file uploaded with success.

    4706. 

  4706.             //  UPLOAD_ERR_INI_SIZE

    4707. 

  4707.             //      Value: 1; The uploaded file exceeds the upload_max_filesize directive in php.ini.

    4708. 

  4708.             //  UPLOAD_ERR_FORM_SIZE

    4709. 

  4709.             //      Value: 2; The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the html form.

    4710. 

  4710.             //  UPLOAD_ERR_PARTIAL

    4711. 

  4711.             //      Value: 3; The uploaded file was only partially uploaded.

    4712. 

  4712.             //  UPLOAD_ERR_NO_FILE

    4713. 

  4713.             //      Value: 4; No file was uploaded.

    4714. 

  4714.             //

    4715. 

  4715.         if (FILEUPLOADS)

    4716. 

  4716.         {

    4717. 

  4717.             if (IsSetSession("FormSavedFiles"))

    4718. 

  4718.             {

    4719. 

  4719.                 $a_saved_files = GetSession("FormSavedFiles");

    4720. 

  4720.                 if (isset($a_saved_files[$s_fld]))

    4721. 

  4721.                     $a_upload = $a_saved_files[$s_fld];

    4722. 

  4722.                 elseif (isset($aFileVars[$s_fld]))

    4723. 

  4723.                     $a_upload = $aFileVars[$s_fld];

    4724. 

  4724.             }

    4725. 

  4725.             elseif (isset($aFileVars[$s_fld]))

    4726. 

  4726.                 $a_upload = $aFileVars[$s_fld];

    4727. 

  4727.         }

    4728. 

  4728.         if (isset($a_upload))

    4729. 

  4729.         {

    4730. 

  4730.             if (isset($a_upload["tmp_name"]) && !empty($a_upload["tmp_name"]) &&

    4731. 

  4731.                 isset($a_upload["name"]) && !empty($a_upload["name"]))

    4732. 

  4732.             {

    4733. 

  4733.                 if (IsUploadedFile($a_upload))

    4734. 

  4734.                     $b_empty = false;

    4735. 

  4735.             }

    4736. 

  4736.             if ($b_empty && isset($a_upload["error"]))

    4737. 

  4737.                 switch ($a_upload["error"])

    4738. 

  4738.                 {

    4739. 

  4739.                 case 1:

    4740. 

  4740.                     $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR1);

    4741. 

  4741.                     break;

    4742. 

  4742.                 case 2:

    4743. 

  4743.                     $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR2);

    4744. 

  4744.                     break;

    4745. 

  4745.                 case 3:

    4746. 

  4746.                     $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR3);

    4747. 

  4747.                     break;

    4748. 

  4748.                 case 4:

    4749. 

  4749.                     $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR4);

    4750. 

  4750.                     break;

    4751. 

  4751.                 case 6:

    4752. 

  4752.                     $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR6);

    4753. 

  4753.                     break;

    4754. 

  4754.                 case 7:

    4755. 

  4755.                     $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR7);

    4756. 

  4756.                     break;

    4757. 

  4757.                 case 8:

    4758. 

  4758.                     $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR8);

    4759. 

  4759.                     break;

    4760. 

  4760.                 default:

    4761. 

  4761.                     $s_mesg = GetMessage(MSG_FILE_UPLOAD_ERR_UNK,

    4762. 

  4762.                                     array("ERRNO"=>$a_upload["error"]));

    4763. 

  4763.                     break;

    4764. 

  4764.                 }

    4765. 

  4765.         }

    4766. 

  4766.     }

    4767. 

  4767.     else

    4768. 

  4768.         $b_empty = FieldManager::IsEmpty($a_main_vars[$s_fld]);

    4769. 

  4769.     return ($b_empty);

    4770. 

  4770. }

    4771. 

  4771. 

    4772. 

  4772.     //

    4773. 

  4773.     // Return a derived field value or value specification.

    4774. 

  4774.     //

    4775. 

  4775. function GetDerivedValue($a_form_data,$s_word,&$a_errors)

    4776. 

  4776. {

    4777. 

  4777.     $s_value = "";

    4778. 

  4778.         //

    4779. 

  4779.         // a field name or a value specification

    4780. 

  4780.         // value specifications have the following format:

    4781. 

  4781.         //      %spec%

    4782. 

  4782.         //

    4783. 

  4783.     if (substr($s_word,0,1) == '%')

    4784. 

  4784.     {

    4785. 

  4785.         if (substr($s_word,-1,1) != '%')

    4786. 

  4786.         {

    4787. 

  4787.             SendAlert(GetMessage(MSG_INV_VALUE_SPEC,array("SPEC"=>$s_word)));

    4788. 

  4788.             $s_value = $s_word;

    4789. 

  4789.         }

    4790. 

  4790.         else

    4791. 

  4791.         {

    4792. 

  4792.             $s_spec = substr($s_word,1,-1);

    4793. 

  4793.             $s_value = ValueSpec($s_spec,$a_form_data,$a_errors);

    4794. 

  4794.         }

    4795. 

  4795.     }

    4796. 

  4796.     else

    4797. 

  4797.     {

    4798. 

  4798.         $s_fld_name = $s_word;

    4799. 

  4799.             //

    4800. 

  4800.             // try form data first, then the environment/server data

    4801. 

  4801.             //

    4802. 

  4802.         if (IsFieldSet($s_fld_name,$a_form_data))

    4803. 

  4803.             $s_value = GetFieldValue($s_fld_name,$a_form_data);

    4804. 

  4804.         elseif (($s_value = GetEnvValue($s_fld_name)) === false)

    4805. 

  4805.             $s_value = "";

    4806. 

  4806.         $s_value = trim($s_value);

    4807. 

  4807.     }

    4808. 

  4808.     return ($s_value);

    4809. 

  4809. }

    4810. 

  4810. 

    4811. 

  4811.     //

    4812. 

  4812.     // Derive a value from the form data using the specification returned

    4813. 

  4813.     // from ParseDerivation.

    4814. 

  4814.     //

    4815. 

  4815. function DeriveValue($a_form_data,$a_value_spec,$s_name,&$a_errors)

    4816. 

  4816. {

    4817. 

  4817.     $s_value = "";

    4818. 

  4818.     for ($ii = 0 ; $ii < count($a_value_spec) ; $ii++)

    4819. 

  4819.     {

    4820. 

  4820.         switch ($a_value_spec[$ii])

    4821. 

  4821.         {

    4822. 

  4822.         case '+':

    4823. 

  4823.                 //

    4824. 

  4824.                 // concatenate with a single space between, but skip the space

    4825. 

  4825.                 // if the next field is empty

    4826. 

  4826.                 //

    4827. 

  4827.             if ($ii < count($a_value_spec)-1)

    4828. 

  4828.             {

    4829. 

  4829.                 $s_temp = GetDerivedValue($a_form_data,$a_value_spec[$ii+1],$a_errors);

    4830. 

  4830.                 if (!FieldManager::IsEmpty($s_temp))

    4831. 

  4831.                     $s_value .= ' ';

    4832. 

  4832.             }

    4833. 

  4833.             break;

    4834. 

  4834.         case '.':

    4835. 

  4835.                 //

    4836. 

  4836.                 // concatenate with no space between

    4837. 

  4837.                 //

    4838. 

  4838.             break;

    4839. 

  4839.         case '*':

    4840. 

  4840.                 //

    4841. 

  4841.                 // concatenate with a single space between

    4842. 

  4842.                 //

    4843. 

  4843.             $s_value .= ' ';

    4844. 

  4844.             break;

    4845. 

  4845.         default:

    4846. 

  4846.                 //

    4847. 

  4847.                 // a field name or a value specification

    4848. 

  4848.                 // value specifications have the following format:

    4849. 

  4849.                 //      %name%

    4850. 

  4850.                 //

    4851. 

  4851.             $s_value .= GetDerivedValue($a_form_data,$a_value_spec[$ii],$a_errors);

    4852. 

  4852.             break;

    4853. 

  4853.         }

    4854. 

  4854.     }

    4855. 

  4855.     return ($s_value);

    4856. 

  4856. }

    4857. 

  4857. 

    4858. 

  4858.     //

    4859. 

  4859.     // Create derived fields specified by the "derive_fields" value.

    4860. 

  4860.     //

    4861. 

  4861. function CreateDerived($a_form_data)

    4862. 

  4862. {

    4863. 

  4863.     if (isset($a_form_data["derive_fields"]))

    4864. 

  4864.     {

    4865. 

  4865.         $a_errors = array();

    4866. 

  4866.             //

    4867. 

  4867.             // get the list of derived field specifications

    4868. 

  4868.             //

    4869. 

  4869.         $a_list = TrimArray(explode(",",$a_form_data["derive_fields"]));

    4870. 

  4870.         foreach ($a_list as $s_fld_spec)

    4871. 

  4871.         {

    4872. 

  4872.             if ($s_fld_spec === "")

    4873. 

  4873.                     //

    4874. 

  4874.                     // silently ignore empty derivations

    4875. 

  4875.                     //

    4876. 

  4876.                 continue;

    4877. 

  4877.             if (($i_pos = strpos($s_fld_spec,"=")) === false)

    4878. 

  4878.             {

    4879. 

  4879.                 $a_errors[] = $s_fld_spec;

    4880. 

  4880.                 continue;

    4881. 

  4881.             }

    4882. 

  4882.             $s_name = trim(substr($s_fld_spec,0,$i_pos));

    4883. 

  4883.             $s_fld_spec = substr($s_fld_spec,$i_pos+1);

    4884. 

  4884. 

    4885. 

  4885.             if (($a_value_spec = ParseDerivation($a_form_data,$s_fld_spec,

    4886. 

  4886.                                                 $s_name,$a_errors)) === false)

    4887. 

  4887.                 break;

    4888. 

  4888.             $a_form_data[$s_name] = DeriveValue($a_form_data,$a_value_spec,$s_name,$a_errors);

    4889. 

  4889.         }

    4890. 

  4890.         if (count($a_errors) > 0)

    4891. 

  4891.         {

    4892. 

  4892.             SendAlert(GetMessage(MSG_DERIVED_INVALID).implode("\n",$a_errors));

    4893. 

  4893.             Error("derivation_failure",GetMessage(MSG_INT_FORM_ERROR));

    4894. 

  4894.         }

    4895. 

  4895.     }

    4896. 

  4896.     return ($a_form_data);

    4897. 

  4897. }

    4898. 

  4898. 

    4899. 

  4899.     //

    4900. 

  4900.     // To process the name specification for files and update the

    4901. 

  4901.     // array of file variables accordingly.

    4902. 

  4902.     //

    4903. 

  4903. function SetFileNames($s_name_spec,$a_order,$a_fields,$a_raw_fields,$a_all_raw_values,$a_file_vars)

    4904. 

  4904. {

    4905. 

  4905.     $a_errors = array();

    4906. 

  4906.         //

    4907. 

  4907.         // get the list of file name derivations

    4908. 

  4908.         //

    4909. 

  4909.     $a_list = TrimArray(explode(",",$s_name_spec));

    4910. 

  4910.     foreach ($a_list as $s_fld_spec)

    4911. 

  4911.     {

    4912. 

  4912.         if ($s_fld_spec === "")

    4913. 

  4913.                 //

    4914. 

  4914.                 // silently ignore empty file name derivations

    4915. 

  4915.                 //

    4916. 

  4916.             continue;

    4917. 

  4917.         if (($i_pos = strpos($s_fld_spec,"=")) === false)

    4918. 

  4918.         {

    4919. 

  4919.             $a_errors[] = $s_fld_spec;

    4920. 

  4920.             continue;

    4921. 

  4921.         }

    4922. 

  4922.         $s_name = trim(substr($s_fld_spec,0,$i_pos));

    4923. 

  4923.         $s_fld_spec = substr($s_fld_spec,$i_pos+1);

    4924. 

  4924. 

    4925. 

  4925.         if (($a_value_spec = ParseDerivation($a_raw_fields,$s_fld_spec,

    4926. 

  4926.                                             $s_name,$a_errors)) === false)

    4927. 

  4927.             break;

    4928. 

  4928.         if (isset($a_file_vars[$s_name]) && IsUploadedFile($a_file_vars[$s_name]))

    4929. 

  4929.         {

    4930. 

  4930.                 //

    4931. 

  4931.                 // we create our own special entry in the file variable's data

    4932. 

  4932.                 //

    4933. 

  4933.             $a_file_vars[$s_name]["new_name"] = DeriveValue($a_raw_fields,

    4934. 

  4934.                                                         $a_value_spec,$s_name,

    4935. 

  4935.                                                         $a_errors);

    4936. 

  4936.                 //

    4937. 

  4937.                 // we also create (derive) a new field called 'name_of_X'

    4938. 

  4938.                 // where X is the file fields's name

    4939. 

  4939.                 //

    4940. 

  4940.             ProcessField("name_of_$s_name",$a_file_vars[$s_name]["new_name"],

    4941. 

  4941.                         $a_order,$a_fields,$a_raw_fields);

    4942. 

  4942.             $a_all_raw_values["name_of_$s_name"] = $a_file_vars[$s_name]["new_name"];

    4943. 

  4943.         }

    4944. 

  4944.         /* This is annoying if a file upload is optional.  Just ignore missing

    4945. 

  4945.             file upload fields.

    4946. 

  4946.         else

    4947. 

  4947.             SendAlert(GetMessage(MSG_FILE_NAMES_NOT_FILE,

    4948. 

  4948.                                             array("NAME"=>$s_name)));*/

    4949. 

  4949.     }

    4950. 

  4950.     if (count($a_errors) > 0)

    4951. 

  4951.     {

    4952. 

  4952.         SendAlert(GetMessage(MSG_FILE_NAMES_INVALID).implode("\n",$a_errors));

    4953. 

  4953.         Error("file_names_derivation_failure",GetMessage(MSG_INT_FORM_ERROR));

    4954. 

  4954.     }

    4955. 

  4955.     return (array($a_order,$a_fields,$a_raw_fields,$a_all_raw_values,$a_file_vars));

    4956. 

  4956. }

    4957. 

  4957. 

    4958. 

  4958.     //

    4959. 

  4959.     // Process a list of attributes or options.

    4960. 

  4960.     // Format for each attribute/option:

    4961. 

  4961.     //      name

    4962. 

  4962.     // or

    4963. 

  4963.     //      name=value

    4964. 

  4964.     //

    4965. 

  4965.     // Values can be simple values or semicolon (;) separated lists:

    4966. 

  4966.     //          avalue

    4967. 

  4967.     //          value1;value2;value3;...

    4968. 

  4968.     //

    4969. 

  4969.     // Returns attribute/options in the associative array $a_attribs.

    4970. 

  4970.     // Optionally, valid attributes can be provided in $a_valid_attribs

    4971. 

  4971.     // (if empty, all attributes found are considered valid).

    4972. 

  4972.     // Errors are returned in $a_errors.

    4973. 

  4973.     //

    4974. 

  4974. function ProcessAttributeList($a_list,&$a_attribs,&$a_errors,

    4975. 

  4975.                         $a_valid_attribs = array())

    4976. 

  4976. {

    4977. 

  4977.     $b_got_valid_list = (count($a_valid_attribs) > 0);

    4978. 

  4978.     foreach ($a_list as $s_attrib)

    4979. 

  4979.     {

    4980. 

  4980.             //

    4981. 

  4981.             // if the name begins with '.' then silently ignore it;

    4982. 

  4982.             // this allows you to temporarily disable an option without

    4983. 

  4983.             // getting an alert message

    4984. 

  4984.             //

    4985. 

  4985.         if (($i_pos = strpos($s_attrib,"=")) === false)

    4986. 

  4986.         {

    4987. 

  4987.             $s_name = trim($s_attrib);

    4988. 

  4988.             if (empty($s_name) || $s_name[0] == '.')

    4989. 

  4989.                 continue;

    4990. 

  4990.                 //

    4991. 

  4991.                 // option is a simple "present" value

    4992. 

  4992.                 //

    4993. 

  4993.             $a_attribs[$s_name] = true;

    4994. 

  4994.         }

    4995. 

  4995.         else

    4996. 

  4996.         {

    4997. 

  4997.             $s_name = trim(substr($s_attrib,0,$i_pos));

    4998. 

  4998.             if (empty($s_name) || $s_name[0] == '.')

    4999. 

  4999.                 continue;

    5000. 

  5000.             $s_value_list = substr($s_attrib,$i_pos+1);

    5001. 

  5001.             if (($i_pos = strpos($s_value_list,";")) === false)

    5002. 

  5002.                     //

    5003. 

  5003.                     // single value

    5004. 

  5004.                     //

    5005. 

  5005.                 $a_attribs[$s_name] = trim($s_value_list);

    5006. 

  5006.             else

    5007. 

  5007.                     //

    5008. 

  5008.                     // list of values

    5009. 

  5009.                     //

    5010. 

  5010.                 $a_attribs[$s_name] = TrimArray(explode(";",$s_value_list));

    5011. 

  5011.         }

    5012. 

  5012.         if ($b_got_valid_list && !isset($a_valid_attribs[$s_name]))

    5013. 

  5013.             $a_errors[] = $s_name;

    5014. 

  5014.     }

    5015. 

  5015. }

    5016. 

  5016. 

    5017. 

  5017.     //

    5018. 

  5018.     // Process the options specified in the form.

    5019. 

  5019.     // Options can be specified in this format:

    5020. 

  5020.     //          option1,option2,option3,...

    5021. 

  5021.     // Each option can be a simple word or a word and value:

    5022. 

  5022.     //          name

    5023. 

  5023.     //          name=value

    5024. 

  5024.     // No name or value can contain a comma.

    5025. 

  5025.     // Values can be simple values or semicolon (;) separated lists:

    5026. 

  5026.     //          avalue

    5027. 

  5027.     //          value1;value2;value3;...

    5028. 

  5028.     // No value can contain a semicolon.

    5029. 

  5029.     // Be careful of values beginning and ending with whitespace characters;

    5030. 

  5030.     // they will be trimmed.

    5031. 

  5031.     //

    5032. 

  5032. function ProcessOptions($s_name,$a_form_data,&$a_options,$a_valid_options)

    5033. 

  5033. {

    5034. 

  5034.     $a_errors = array();

    5035. 

  5035.     $a_options = array();

    5036. 

  5036.     if (isset($a_form_data[$s_name]))

    5037. 

  5037.     {

    5038. 

  5038.             //

    5039. 

  5039.             // get the options list and trim each one

    5040. 

  5040.             //

    5041. 

  5041.         $a_list = TrimArray(explode(",",$a_form_data[$s_name]));

    5042. 

  5042.         ProcessAttributeList($a_list,$a_options,$a_errors,$a_valid_options);

    5043. 

  5043.     }

    5044. 

  5044.     if (count($a_errors) > 0)

    5045. 

  5045.         SendAlert(GetMessage(MSG_OPTIONS_INVALID,array("OPT"=>$s_name)).

    5046. 

  5046.                     implode("\n",$a_errors));

    5047. 

  5047. }

    5048. 

  5048. 

    5049. 

  5049.     //

    5050. 

  5050.     // Process the mail_options specified in the form.

    5051. 

  5051.     //

    5052. 

  5052. function ProcessMailOptions($a_form_data)

    5053. 

  5053. {

    5054. 

  5054.     global  $MAIL_OPTS,$VALID_MAIL_OPTIONS;

    5055. 

  5055. 

    5056. 

  5056.     ProcessOptions("mail_options",$a_form_data,$MAIL_OPTS,$VALID_MAIL_OPTIONS);

    5057. 

  5057. }

    5058. 

  5058. 

    5059. 

  5059.     //

    5060. 

  5060.     // Check if an option is set

    5061. 

  5061.     //

    5062. 

  5062. function IsMailOptionSet($s_name)

    5063. 

  5063. {

    5064. 

  5064.     global  $MAIL_OPTS;

    5065. 

  5065. 

    5066. 

  5066.     return (isset($MAIL_OPTS[$s_name]));

    5067. 

  5067. }

    5068. 

  5068. 

    5069. 

  5069.     //

    5070. 

  5070.     // Return an option's value or NULL if not set.

    5071. 

  5071.     //

    5072. 

  5072. function GetMailOption($s_name)

    5073. 

  5073. {

    5074. 

  5074.     global  $MAIL_OPTS;

    5075. 

  5075. 

    5076. 

  5076.     return (isset($MAIL_OPTS[$s_name]) ? $MAIL_OPTS[$s_name] : NULL);

    5077. 

  5077. }

    5078. 

  5078. 

    5079. 

  5079.     //

    5080. 

  5080.     // Process the crm_options specified in the form.

    5081. 

  5081.     //

    5082. 

  5082. function ProcessCRMOptions($a_form_data)

    5083. 

  5083. {

    5084. 

  5084.     global  $CRM_OPTS,$VALID_CRM_OPTIONS;

    5085. 

  5085. 

    5086. 

  5086.     ProcessOptions("crm_options",$a_form_data,$CRM_OPTS,$VALID_CRM_OPTIONS);

    5087. 

  5087. }

    5088. 

  5088. 

    5089. 

  5089.     //

    5090. 

  5090.     // Check if an option is set

    5091. 

  5091.     //

    5092. 

  5092. function IsCRMOptionSet($s_name)

    5093. 

  5093. {

    5094. 

  5094.     global  $CRM_OPTS;

    5095. 

  5095. 

    5096. 

  5096.     return (isset($CRM_OPTS[$s_name]));

    5097. 

  5097. }

    5098. 

  5098. 

    5099. 

  5099.     //

    5100. 

  5100.     // Return an option's value or NULL if not set.

    5101. 

  5101.     //

    5102. 

  5102. function GetCRMOption($s_name)

    5103. 

  5103. {

    5104. 

  5104.     global  $CRM_OPTS;

    5105. 

  5105. 

    5106. 

  5106.     return (isset($CRM_OPTS[$s_name]) ? $CRM_OPTS[$s_name] : NULL);

    5107. 

  5107. }

    5108. 

  5108. 

    5109. 

  5109.     //

    5110. 

  5110.     // Check if a field is in the mail exclusion list.

    5111. 

  5111.     //

    5112. 

  5112. function IsMailExcluded($s_name)

    5113. 

  5113. {

    5114. 

  5114.     $a_list = GetMailOption("Exclude");

    5115. 

  5115.     if (!isset($a_list))

    5116. 

  5116.         return (false);

    5117. 

  5117.     if (is_array($a_list))

    5118. 

  5118.         return (in_array($s_name,$a_list));

    5119. 

  5119.     else

    5120. 

  5120.         return ($s_name === $a_list);

    5121. 

  5121. }

    5122. 

  5122. 

    5123. 

  5123.     //

    5124. 

  5124.     // Process the autorespond specified in the form.

    5125. 

  5125.     //

    5126. 

  5126. function ProcessAROptions($a_form_data)

    5127. 

  5127. {

    5128. 

  5128.     global  $AR_OPTS,$VALID_AR_OPTIONS;

    5129. 

  5129. 

    5130. 

  5130.     ProcessOptions("autorespond",$a_form_data,$AR_OPTS,$VALID_AR_OPTIONS);

    5131. 

  5131. }

    5132. 

  5132. 

    5133. 

  5133.     //

    5134. 

  5134.     // Check if an option is set

    5135. 

  5135.     //

    5136. 

  5136. function IsAROptionSet($s_name)

    5137. 

  5137. {

    5138. 

  5138.     global  $AR_OPTS;

    5139. 

  5139. 

    5140. 

  5140.     return (isset($AR_OPTS[$s_name]));

    5141. 

  5141. }

    5142. 

  5142. 

    5143. 

  5143.     //

    5144. 

  5144.     // Return an option's value or NULL if not set.

    5145. 

  5145.     //

    5146. 

  5146. function GetAROption($s_name)

    5147. 

  5147. {

    5148. 

  5148.     global  $AR_OPTS;

    5149. 

  5149. 

    5150. 

  5150.     return (isset($AR_OPTS[$s_name]) ? $AR_OPTS[$s_name] : NULL);

    5151. 

  5151. }

    5152. 

  5152. 

    5153. 

  5153.     //

    5154. 

  5154.     // Process the mail_options specified in the form.

    5155. 

  5155.     //

    5156. 

  5156. function ProcessFilterOptions($a_form_data)

    5157. 

  5157. {

    5158. 

  5158.     global  $FILTER_OPTS,$VALID_FILTER_OPTIONS;

    5159. 

  5159. 

    5160. 

  5160.     ProcessOptions("filter_options",$a_form_data,$FILTER_OPTS,$VALID_FILTER_OPTIONS);

    5161. 

  5161. }

    5162. 

  5162. 

    5163. 

  5163.     //

    5164. 

  5164.     // Check if an option is set

    5165. 

  5165.     //

    5166. 

  5166. function IsFilterOptionSet($s_name)

    5167. 

  5167. {

    5168. 

  5168.     global  $FILTER_OPTS;

    5169. 

  5169. 

    5170. 

  5170.     return (isset($FILTER_OPTS[$s_name]));

    5171. 

  5171. }

    5172. 

  5172. 

    5173. 

  5173.     //

    5174. 

  5174.     // Return an option's value or NULL if not set.

    5175. 

  5175.     //

    5176. 

  5176. function GetFilterOption($s_name)

    5177. 

  5177. {

    5178. 

  5178.     global  $FILTER_OPTS;

    5179. 

  5179. 

    5180. 

  5180.     return (isset($FILTER_OPTS[$s_name]) ? $FILTER_OPTS[$s_name] : NULL);

    5181. 

  5181. }

    5182. 

  5182. 

    5183. 

  5183.     //

    5184. 

  5184.     // Lookup a filter attribute for the given filter.

    5185. 

  5185.     // Return it's value or false if not set.

    5186. 

  5186.     //

    5187. 

  5187. function GetFilterAttrib($s_filter,$s_attrib)

    5188. 

  5188. {

    5189. 

  5189.     global  $FILTER_ATTRIBS,$FILTER_ATTRIBS_LOOKUP;

    5190. 

  5190. 

    5191. 

  5191.     if (!isset($FILTER_ATTRIBS[$s_filter]))

    5192. 

  5192.             //

    5193. 

  5193.             // no attributes for the filter

    5194. 

  5194.             //

    5195. 

  5195.         return (false);

    5196. 

  5196.     if (!isset($FILTER_ATTRIBS_LOOKUP[$s_filter]))

    5197. 

  5197.     {

    5198. 

  5198.             //

    5199. 

  5199.             // the attributes have not yet been parsed - create the lookup table

    5200. 

  5200.             //

    5201. 

  5201.         $a_list = TrimArray(explode(",",$FILTER_ATTRIBS[$s_filter]));

    5202. 

  5202.         $FILTER_ATTRIBS_LOOKUP[$s_filter] = array();

    5203. 

  5203.         $a_errors = array();

    5204. 

  5204. 

    5205. 

  5205.         ProcessAttributeList($a_list,$FILTER_ATTRIBS_LOOKUP[$s_filter],$a_errors);

    5206. 

  5206.     }

    5207. 

  5207.         //

    5208. 

  5208.         // perform the lookup and return the value

    5209. 

  5209.         //

    5210. 

  5210.     if (!isset($FILTER_ATTRIBS_LOOKUP[$s_filter][$s_attrib]))

    5211. 

  5211.         return (false);

    5212. 

  5212.     return ($FILTER_ATTRIBS_LOOKUP[$s_filter][$s_attrib]);

    5213. 

  5213. }

    5214. 

  5214. 

    5215. 

  5215.     //

    5216. 

  5216.     // Check the filter attributes for the given filter.

    5217. 

  5217.     // Return true if the given attribute is set otherwise false.

    5218. 

  5218.     //

    5219. 

  5219. function IsFilterAttribSet($s_filter,$s_attrib)

    5220. 

  5220. {

    5221. 

  5221.     return (GetFilterAttrib($s_filter,$s_attrib));

    5222. 

  5222. }

    5223. 

  5223. 

    5224. 

  5224.     //

    5225. 

  5225.     // Process the given .ini file.

    5226. 

  5226.     //

    5227. 

  5227. function ProcessFormIniFile($s_file)

    5228. 

  5228. {

    5229. 

  5229.     global  $EMAIL_ADDRS,$ValidEmails;

    5230. 

  5230. 

    5231. 

  5231.     $a_sections = parse_ini_file($s_file,TRUE);

    5232. 

  5232.         //

    5233. 

  5233.         // from PHP 5.2.7, parse_ini_file returns false on syntax problems

    5234. 

  5234.         // prior to that, an empty array.  So, on previous versions of PHP

    5235. 

  5235.         // we cannot detect an actual error (an empty array is perfectly valid).

    5236. 

  5236.         //

    5237. 

  5237.     if ($a_sections === false)

    5238. 

  5238.         Error("bad_ini",GetMessage(MSG_INI_PARSE_ERROR,array("FILE"=>$s_file)));

    5239. 

  5239.     elseif (empty($a_sections))

    5240. 

  5240.         SendAlert(GetMessage(MSG_INI_PARSE_WARN,array("FILE"=>$s_file)),false,true);

    5241. 

  5241.     if (DB_SEE_INI)

    5242. 

  5242.     {

    5243. 

  5243.             //

    5244. 

  5244.             // just display the ini file

    5245. 

  5245.             //

    5246. 

  5246.         $s_text = "<p><b>The following settings were found in the file '$s_file':</b></p>";

    5247. 

  5247.         foreach ($a_sections as $s_sect=>$a_settings)

    5248. 

  5248.         {

    5249. 

  5249.             $s_text .= "<p>[$s_sect]\n";

    5250. 

  5250.             foreach ($a_settings as $s_name=>$s_value)

    5251. 

  5251.                 $s_text .= "$s_name = \"$s_value\"\n";

    5252. 

  5252.             $s_text .= "</p>";

    5253. 

  5253.         }

    5254. 

  5254.         CreatePage($s_text,"Debug Output - INI File Display");

    5255. 

  5255.         exit;

    5256. 

  5256.     }

    5257. 

  5257.         //

    5258. 

  5258.         // Load the email_addresses section.

    5259. 

  5259.         //

    5260. 

  5260.     if (isset($a_sections["email_addresses"]))

    5261. 

  5261.     {

    5262. 

  5262.         $EMAIL_ADDRS = $a_sections["email_addresses"];

    5263. 

  5263.             //

    5264. 

  5264.             // make these addresses valid

    5265. 

  5265.             //

    5266. 

  5266.         foreach ($EMAIL_ADDRS as $s_list)

    5267. 

  5267.             $ValidEmails->AddAddresses($s_list);

    5268. 

  5268.     }

    5269. 

  5269.         //

    5270. 

  5270.         // Process special fields

    5271. 

  5271.         //

    5272. 

  5272.     if (isset($a_sections["special_fields"]))

    5273. 

  5273.     {

    5274. 

  5274.         foreach ($a_sections["special_fields"] as $s_name=>$m_value)

    5275. 

  5275.         {

    5276. 

  5276.             if (IsSpecialField($s_name))

    5277. 

  5277.             {

    5278. 

  5278.                 SetSpecialField($s_name,$m_value);

    5279. 

  5279.                     //

    5280. 

  5280.                     // if this is the recipients, cc, or bcc field,

    5281. 

  5281.                     // make the addresses valid

    5282. 

  5282.                     //

    5283. 

  5283.                 if ($s_name === "recipients" || $s_name === "cc" || $s_name === "bcc")

    5284. 

  5284.                         //

    5285. 

  5285.                         // coming from the INI file, the values can only be strings

    5286. 

  5286.                         //

    5287. 

  5287.                     if (is_string($m_value))

    5288. 

  5288.                         $ValidEmails->AddAddresses($m_value);

    5289. 

  5289.             }

    5290. 

  5290.                 //

    5291. 

  5291.                 // check for multiple valued special fields

    5292. 

  5292.                 //

    5293. 

  5293.             if (($a_multi_fld = IsSpecialMultiField($s_name)) !== false)

    5294. 

  5294.                 SetSpecialMultiField($a_multi_fld[0],$a_multi_fld[1],$m_value);

    5295. 

  5295.         }

    5296. 

  5296.     }

    5297. 

  5297. }

    5298. 

  5298. 

    5299. 

  5299.     //

    5300. 

  5300.     // UnMangle an email address

    5301. 

  5301.     //

    5302. 

  5302. function UnMangle($email)

    5303. 

  5303. {

    5304. 

  5304.     global  $EMAIL_ADDRS;

    5305. 

  5305. 

    5306. 

  5306.         //

    5307. 

  5307.         // map from a name to the real email address

    5308. 

  5308.         //

    5309. 

  5309.     if (isset($EMAIL_ADDRS[$email]))

    5310. 

  5310.         $email = $EMAIL_ADDRS[$email];

    5311. 

  5311.         //

    5312. 

  5312.         // unmangle

    5313. 

  5313.         //

    5314. 

  5314.     if (AT_MANGLE != "")

    5315. 

  5315.         $email = str_replace(AT_MANGLE,"@",$email);

    5316. 

  5316.     return ($email);

    5317. 

  5317. }

    5318. 

  5318. 

    5319. 

  5319.     //

    5320. 

  5320.     // Check a list of email addresses (comma separated); returns a list

    5321. 

  5321.     // of valid email addresses (comma separated).

    5322. 

  5322.     // The list can be an array of comma separated lists.

    5323. 

  5323.     // The return value is true if there is at least one valid email address.

    5324. 

  5324.     //

    5325. 

  5325. function CheckEmailAddress($m_addr,&$s_valid,&$s_invalid,$b_check = true)

    5326. 

  5326. {

    5327. 

  5327.     global  $ValidEmails;

    5328. 

  5328. 

    5329. 

  5329.     $s_invalid = $s_valid = "";

    5330. 

  5330.     if (is_array($m_addr))

    5331. 

  5331.     {

    5332. 

  5332.         $a_list = array();

    5333. 

  5333.         foreach ($m_addr as $s_addr_list)

    5334. 

  5334.             $a_list = array_merge($a_list,TrimArray(explode(",",$s_addr_list)));

    5335. 

  5335.     }

    5336. 

  5336.     else

    5337. 

  5337.         $a_list = TrimArray(explode(",",$m_addr));

    5338. 

  5338.     $a_invalid = array();

    5339. 

  5339.     $n_empty = 0;

    5340. 

  5340.     for ($ii = 0 ; $ii < count($a_list) ; $ii++)

    5341. 

  5341.     {

    5342. 

  5342.         if ($a_list[$ii] === "")

    5343. 

  5343.         {

    5344. 

  5344.                 //

    5345. 

  5345.                 // ignore, but count empty addresses

    5346. 

  5346.                 //

    5347. 

  5347.             $n_empty++;

    5348. 

  5348.             continue;

    5349. 

  5349.         }

    5350. 

  5350.         $s_email = UnMangle($a_list[$ii]);

    5351. 

  5351.             //

    5352. 

  5352.             // UnMangle works with INI files too, and a single

    5353. 

  5353.             // word can expand to a list of email addresses.

    5354. 

  5354.             //

    5355. 

  5355.         $a_this_list = TrimArray(explode(",",$s_email));

    5356. 

  5356.         foreach ($a_this_list as $s_email)

    5357. 

  5357.         {

    5358. 

  5358.             if ($s_email === "")

    5359. 

  5359.             {

    5360. 

  5360.                     //

    5361. 

  5361.                     // ignore, but count empty addresses

    5362. 

  5362.                     //

    5363. 

  5363.                 $n_empty++;

    5364. 

  5364.                 continue;

    5365. 

  5365.             }

    5366. 

  5366.             if ($b_check)

    5367. 

  5367.                 $b_is_valid = $ValidEmails->CheckAddress($s_email);

    5368. 

  5368.             else

    5369. 

  5369.                 $b_is_valid = true;

    5370. 

  5370.             if ($b_is_valid)

    5371. 

  5371.             {

    5372. 

  5372.                 if (empty($s_valid))

    5373. 

  5373.                     $s_valid = $s_email;

    5374. 

  5374.                 else

    5375. 

  5375.                     $s_valid .= ",".$s_email;

    5376. 

  5376.             }

    5377. 

  5377.             else

    5378. 

  5378.                 $a_invalid[] = $s_email;

    5379. 

  5379.         }

    5380. 

  5380.     }

    5381. 

  5381.         //

    5382. 

  5382.         // just ignore empty recipients unless there are *no* valid recipients

    5383. 

  5383.         //

    5384. 

  5384.     if (empty($s_valid) && $n_empty > 0)

    5385. 

  5385.         $a_invalid[] = GetMessage(MSG_EMPTY_ADDRESSES,array("COUNT"=>$n_empty));

    5386. 

  5386.     if (count($a_invalid) > 0)

    5387. 

  5387.         $s_invalid = implode(",",$a_invalid);

    5388. 

  5388.     return (!empty($s_valid));

    5389. 

  5389. }

    5390. 

  5390. 

    5391. 

  5391.     //

    5392. 

  5392.     // Redirect to another URL

    5393. 

  5393.     //

    5394. 

  5394. function Redirect($url,$title)

    5395. 

  5395. {

    5396. 

  5396.         //

    5397. 

  5397.         // for browsers without cookies enabled, append the Session ID

    5398. 

  5398.         //

    5399. 

  5399.     if (session_id() !== "")

    5400. 

  5400.         $url = AddURLParams($url,session_name()."=".urlencode(session_id()));

    5401. 

  5401.     elseif (defined("SID"))

    5402. 

  5402.         $url = AddURLParams($url,SID);

    5403. 

  5403. 

    5404. 

  5404.     //FMDebug("Before redirecting, FormData = ".(isset($_SESSION["FormData"]) ? var_export($_SESSION["FormData"],true) : "NULL"));

    5405. 

  5405. 

    5406. 

  5406.         //

    5407. 

  5407.         // this is probably a good idea to ensure the session data

    5408. 

  5408.         // is written away

    5409. 

  5409.         //

    5410. 

  5410.     if (function_exists('session_write_close'))

    5411. 

  5411.         session_write_close();

    5412. 

  5412. 

    5413. 

  5413.     header("Location: $url");

    5414. 

  5414.         //

    5415. 

  5415.         // if the header doesn't work, try JavaScript.

    5416. 

  5416.         // if that doesn't work, provide a manual link

    5417. 

  5417.         //

    5418. 

  5418.     $s_text = GetMessage(MSG_PLSWAIT_REDIR)."\n\n";

    5419. 

  5419.     $s_text .= "<script language=\"JavaScript\" type=\"text/javascript\">";

    5420. 

  5420.     $s_text .= "window.location.href = '$url';";

    5421. 

  5421.     $s_text .= "</script>";

    5422. 

  5422.     $s_text .= "\n\n".GetMessage(MSG_IFNOT_REDIR,array("URL"=>$url));

    5423. 

  5423.     CreatePage($s_text,$title);

    5424. 

  5424.     exit;

    5425. 

  5425. }

    5426. 

  5426. 

    5427. 

  5427. class   JSON

    5428. 

  5428. {

    5429. 

  5429.     function    _Format($m_val)

    5430. 

  5430.     {

    5431. 

  5431.         if (is_bool($m_val))

    5432. 

  5432.             $s_value = ($m_val) ? "true" : "false";

    5433. 

  5433.         elseif (is_string($m_val))

    5434. 

  5434.             $s_value = '"'.addslashes($m_val).'"';

    5435. 

  5435.         elseif (is_numeric($m_val))

    5436. 

  5436.             $s_value = $m_val;

    5437. 

  5437.         elseif (is_array($m_val))

    5438. 

  5438.             $s_value = $this->_FormatArray($m_val);

    5439. 

  5439.         else

    5440. 

  5440.             $s_value = "null";

    5441. 

  5441.         return ($s_value);

    5442. 

  5442.     }

    5443. 

  5443.     

    5444. 

  5444.     function _FormatArray($a_array)

    5445. 

  5445.     {

    5446. 

  5446.         if ($this->_IsNumericArray($a_array))

    5447. 

  5447.         {

    5448. 

  5448.             $a_values = array();

    5449. 

  5449.             foreach ($a_array as $m_val)

    5450. 

  5450.                 $a_values[] = $this->_Format($m_val);

    5451. 

  5451.             $s_value = "[".implode(",",$a_values)."]";

    5452. 

  5452.         }

    5453. 

  5453.         else

    5454. 

  5454.         {

    5455. 

  5455.                 //

    5456. 

  5456.                 // associative arrays are objects

    5457. 

  5457.                 //

    5458. 

  5458.             $s_value = $this->MakeObject($a_array);

    5459. 

  5459.         }

    5460. 

  5460.         return ($s_value);

    5461. 

  5461.     }

    5462. 

  5462.     

    5463. 

  5463.     //

    5464. 

  5464.     // check if we have a numeric array or an associative array

    5465. 

  5465.     // numeric arrays may have holes; numeric array indexes must

    5466. 

  5466.     // be integers

    5467. 

  5467.     //

    5468. 

  5468.     function _IsNumericArray($a_data)

    5469. 

  5469.     {

    5470. 

  5470.         if (empty($a_data))

    5471. 

  5471.             return (true);      // empty array - treat as numeric

    5472. 

  5472.         //

    5473. 

  5473.         // check all the keys for numeric

    5474. 

  5474.         //

    5475. 

  5475.         $a_keys = array_keys($a_data);

    5476. 

  5476.         foreach ($a_keys as $m_index)

    5477. 

  5477.             if (!is_int($m_index))

    5478. 

  5478.                 return (false);

    5479. 

  5479.         return (true);

    5480. 

  5480.     }

    5481. 

  5481.     

    5482. 

  5482.     function    MakeObject($a_data)

    5483. 

  5483.     {

    5484. 

  5484.         $a_members = array();

    5485. 

  5485.         foreach ($a_data as $s_key=>$m_val)

    5486. 

  5486.             $a_members[] = '"'.$s_key.'":'.$this->_Format($m_val);

    5487. 

  5487.         return ("{".implode(",",$a_members)."}");

    5488. 

  5488.     }

    5489. 

  5489. }

    5490. 

  5490. 

    5491. 

  5491. function    CORS_Response()

    5492. 

  5492. {

    5493. 

  5493.     header('Access-Control-Allow-Origin: *');

    5494. 

  5494.     header('Access-Control-Max-Age: 36000');

    5495. 

  5495.     header('Access-Control-Allow-Methods: GET, POST, OPTIONS');

    5496. 

  5496.     header('Access-Control-Allow-Headers: X-Requested-With');

    5497. 

  5497. }

    5498. 

  5498. 

    5499. 

  5499. function    JSON_Result($s_result,$a_data = array())

    5500. 

  5500. {

    5501. 

  5501.     global  $aGetVars;

    5502. 

  5502.     

    5503. 

  5503.     FMDebug("Sending JSON_Result: $s_result");

    5504. 

  5504.     $a_data["Result"] = $s_result;

    5505. 

  5505.     $json = new JSON();

    5506. 

  5506.     $s_ret = $json->MakeObject($a_data);

    5507. 

  5507.     CORS_Response();

    5508. 

  5508.     //

    5509. 

  5509.     // handle JSONP request

    5510. 

  5510.     //

    5511. 

  5511.     if (isset($aGetVars['callback']) && $aGetVars['callback'] != '')

    5512. 

  5512.     {

    5513. 

  5513.         header('Content-Type: text/javascript; charset=utf-8');

    5514. 

  5514.         $s_ret = $aGetVars['callback']."($s_ret);";

    5515. 

  5515.         FMDebug('JSONP request callback='.$aGetVars['callback']);

    5516. 

  5516.     }

    5517. 

  5517.     else

    5518. 

  5518.     {

    5519. 

  5519.         header('Content-Encoding: utf-8');

    5520. 

  5520.         header('Content-Type: application/json; charset=utf-8');

    5521. 

  5521.     }

    5522. 

  5522.     FMDebug("JSON_Result output: ".$s_ret);

    5523. 

  5523.     echo $s_ret;

    5524. 

  5524. }

    5525. 

  5525. 

    5526. 

  5526.     //

    5527. 

  5527.     // JoinLines is just like "implode" except that it checks

    5528. 

  5528.     // the end of each array for the separator already being

    5529. 

  5529.     // there. This allows us to join a mixture of mail

    5530. 

  5530.     // header lines (already terminated) with body lines.

    5531. 

  5531.     // This logic works if HEAD_CRLF, for example, is the same

    5532. 

  5532.     // as BODY_LF (i.e. both "\r\n") or if BODY_LF is the

    5533. 

  5533.     // same as the last character in HEAD_CRLF (i.e.

    5534. 

  5534.     // HEAD_CRLF = "\r\n" and BODY_LF = "\n").

    5535. 

  5535.     // Other value combinations may break things.

    5536. 

  5536.     //

    5537. 

  5537. function JoinLines($s_sep,$a_lines)

    5538. 

  5538. {

    5539. 

  5539.     $s_str = "";

    5540. 

  5540.     if (($i_sep_len = strlen($s_sep)) == 0)

    5541. 

  5541.             //

    5542. 

  5542.             // no separator

    5543. 

  5543.             //

    5544. 

  5544.         return (implode("",$a_lines));

    5545. 

  5545.     $n_lines = count($a_lines);

    5546. 

  5546.     for ($ii = 0 ; $ii < $n_lines ; $ii++)

    5547. 

  5547.     {

    5548. 

  5548.         $s_line = $a_lines[$ii];

    5549. 

  5549.         if (substr($s_line,-$i_sep_len) == $s_sep)

    5550. 

  5550.             $s_str .= $s_line;

    5551. 

  5551.         else

    5552. 

  5552.         {

    5553. 

  5553.             $s_str .= $s_line;

    5554. 

  5554.                 //

    5555. 

  5555.                 // don't append a separator to the last line

    5556. 

  5556.                 //

    5557. 

  5557.             if ($ii < $n_lines-1)

    5558. 

  5558.                 $s_str .= $s_sep;

    5559. 

  5559.         }

    5560. 

  5560.     }

    5561. 

  5561.     return ($s_str);

    5562. 

  5562. }

    5563. 

  5563. 

    5564. 

  5564.     //

    5565. 

  5565.     // Re-orders an array of email headers into the

    5566. 

  5566.     // order recommended by RFC822, section 4.1:

    5567. 

  5567.     //      It  is  recommended that,  if  present,

    5568. 

  5568.     //      headers be sent in the order "Return-

    5569. 

  5569.     //      Path", "Received", "Date",  "From",  "Subject",

    5570. 

  5570.     //      "Sender", "To", "cc", etc.

    5571. 

  5571.     //

    5572. 

  5572.     // Note that RFC822 is obsoleted by RFC2822 and

    5573. 

  5573.     // the latter states that field order doesn't

    5574. 

  5574.     // matter (except for some tracing fields).

    5575. 

  5575.     // However, a FormMail user reported that Yahoo doesn't like

    5576. 

  5576.     // email where the CC header appears before the From

    5577. 

  5577.     // header. So, as always, we try to work with broken

    5578. 

  5578.     // servers too...

    5579. 

  5579.     //

    5580. 

  5580.     // Returns an array indexed by the require numerical

    5581. 

  5581.     // order.  Each element is an array containing the

    5582. 

  5582.     // header value (name,value pair).

    5583. 

  5583.     //

    5584. 

  5584. function OrderHeaders($a_headers)

    5585. 

  5585. {

    5586. 

  5586.         //

    5587. 

  5587.         // we list the headers we're responsible for

    5588. 

  5588.         // in the order suggested

    5589. 

  5589.         //

    5590. 

  5590.     $a_ordering = array("From","Subject","To","Cc","Bcc","Reply-To");

    5591. 

  5591.     $a_ordered_headers = array();

    5592. 

  5592.     foreach ($a_ordering as $s_name)

    5593. 

  5593.     {

    5594. 

  5594.         if (isset($a_headers[$s_name]))

    5595. 

  5595.         {

    5596. 

  5596.             $a_ordered_headers[] = array($s_name=>$a_headers[$s_name]);

    5597. 

  5597.             unset($a_headers[$s_name]);

    5598. 

  5598.         }

    5599. 

  5599.     }

    5600. 

  5600.         //

    5601. 

  5601.         // now add in the remaining headers

    5602. 

  5602.         //

    5603. 

  5603.     foreach ($a_headers as $s_name=>$s_value)

    5604. 

  5604.         $a_ordered_headers[] = array($s_name=>$a_headers[$s_name]);

    5605. 

  5605.     return ($a_ordered_headers);

    5606. 

  5606. }

    5607. 

  5607. 

    5608. 

  5608.     //

    5609. 

  5609.     // Makes a mail header field body "safe".

    5610. 

  5610.     // This simply places a backslash in front of every double-quote.

    5611. 

  5611.     // There's probably more we could do if required, but this

    5612. 

  5612.     // attempts to provide the same protection that was in the first

    5613. 

  5613.     // version of FormMail.  In that version, every incoming

    5614. 

  5614.     // field had double-quotes replaced with single quotes.

    5615. 

  5615.     // That processing is no longer performed, and this

    5616. 

  5616.     // function is used to protect against potential attacks in

    5617. 

  5617.     // header fields - not by replacing double quotes with single quotes,

    5618. 

  5618.     // but by using the backslash "quoting" feature of RFC2822.

    5619. 

  5619.     //

    5620. 

  5620.     // This code could be improved by parsing the header and rewriting

    5621. 

  5621.     // it to be valid, possibly removing junk.

    5622. 

  5622.     //

    5623. 

  5623.     // That's a lot of code, though!

    5624. 

  5624.     //

    5625. 

  5625. function    SafeHeader($s_str)

    5626. 

  5626. {

    5627. 

  5627.     return (str_replace('"','\\"',$s_str));

    5628. 

  5628. }

    5629. 

  5629. 

    5630. 

  5630.     //

    5631. 

  5631.     // makes a string safe to put as words in a header

    5632. 

  5632.     //

    5633. 

  5633. function    SafeHeaderWords($s_str)

    5634. 

  5634. {

    5635. 

  5635.         //

    5636. 

  5636.         // We zap various characters and replace them with a question mark.

    5637. 

  5637.         // Also, we don't handle quoted strings, which are valid words.

    5638. 

  5638.         //

    5639. 

  5639.     $s_specials = '()<>@,;:\\".[]';    // special characters defined by RFC822

    5640. 

  5640.     $s_str = preg_replace('/[[:cntrl:]]+/',"?",$s_str);    // zap all control chars

    5641. 

  5641.     $s_str = preg_replace("/[".preg_quote($s_specials,"/")."]/","?",$s_str);    // zap all specials

    5642. 

  5642.     return ($s_str);

    5643. 

  5643. }

    5644. 

  5644. 

    5645. 

  5645.     //

    5646. 

  5646.     // makes a string safe to put as a quoted string in a header

    5647. 

  5647.     //

    5648. 

  5648. function    SafeHeaderQString($s_str)

    5649. 

  5649. {

    5650. 

  5650.     return (str_replace('"','\\"',

    5651. 

  5651.                 str_replace("\\","\\\\",

    5652. 

  5652.                     str_replace("\r"," ",

    5653. 

  5653.                         str_replace("\r\n"," ",$s_str)))));

    5654. 

  5654. }

    5655. 

  5655. 

    5656. 

  5656.     //

    5657. 

  5657.     // makes a string safe to put in a header comment

    5658. 

  5658.     //

    5659. 

  5659. function    SafeHeaderComment($s_str)

    5660. 

  5660. {

    5661. 

  5661.     return (str_replace("(","\\(",

    5662. 

  5662.                 str_replace(")","\\)",

    5663. 

  5663.                     str_replace("\\","\\\\",

    5664. 

  5664.                         str_replace("\r"," ",

    5665. 

  5665.                             str_replace("\r\n"," ",$s_str))))));

    5666. 

  5666. }

    5667. 

  5667. 

    5668. 

  5668.     //

    5669. 

  5669.     // makes a string safe to put in a header as an email address

    5670. 

  5670.     //

    5671. 

  5671. function    SafeHeaderEmail($s_str)

    5672. 

  5672. {

    5673. 

  5673.         //

    5674. 

  5674.         // An email address is made up of local and domain parts

    5675. 

  5675.         // each of these is made up of "words" separated by "."

    5676. 

  5676.         // each "word" can be a sequence of characters excluding

    5677. 

  5677.         // specials, space and control characters OR it can be

    5678. 

  5678.         // a quoted string.

    5679. 

  5679.         //

    5680. 

  5680.         // The correct processing would be to completely

    5681. 

  5681.         // parse the address, strip junk, double-quote

    5682. 

  5682.         // words that need to be turned into quote strings,

    5683. 

  5683.         // and return a well-formed email address.

    5684. 

  5684.         //

    5685. 

  5685.         // That's a lot of code!

    5686. 

  5686.         //

    5687. 

  5687.         // So, instead, we opt for stripping out control characters.

    5688. 

  5688.         //

    5689. 

  5689.     $s_str = preg_replace('/[[:cntrl:]]+/',"",$s_str);    // zap all control chars

    5690. 

  5690.     return ($s_str);

    5691. 

  5691. }

    5692. 

  5692. 

    5693. 

  5693.     //

    5694. 

  5694.     // Expands an array of mail headers into mail header lines.

    5695. 

  5695.     //

    5696. 

  5696. function ExpandMailHeaders($a_headers,$b_fold = false)

    5697. 

  5697. {

    5698. 

  5698.     $s_hdrs = "";

    5699. 

  5699.     $a_ordered_headers = OrderHeaders($a_headers);

    5700. 

  5700.     for ($ii = 0 ; $ii < count($a_ordered_headers) ; $ii++)

    5701. 

  5701.     {

    5702. 

  5702.         foreach ($a_ordered_headers[$ii] as $s_name=>$s_value)

    5703. 

  5703.             if ($s_name != "")

    5704. 

  5704.             {

    5705. 

  5705.                 if ($s_hdrs != "")

    5706. 

  5706.                     $s_hdrs .= HEAD_CRLF;

    5707. 

  5707.                 if ($b_fold)

    5708. 

  5708.                     $s_hdrs .= HeaderFolding($s_name.": ".$s_value);

    5709. 

  5709.                 else

    5710. 

  5710.                     $s_hdrs .= $s_name.": ".$s_value;

    5711. 

  5711.             }

    5712. 

  5712.     }

    5713. 

  5713.     //FMDebug("Headers are: $s_hdrs");

    5714. 

  5714.     return ($s_hdrs);

    5715. 

  5715. }

    5716. 

  5716. 

    5717. 

  5717.     //

    5718. 

  5718.     // Expands an array of mail headers into an array containing header lines.

    5719. 

  5719.     //

    5720. 

  5720. function ExpandMailHeadersArray($a_headers)

    5721. 

  5721. {

    5722. 

  5722.     $a_hdrs = array();

    5723. 

  5723.     $a_ordered_headers = OrderHeaders($a_headers);

    5724. 

  5724.     for ($ii = 0 ; $ii < count($a_ordered_headers) ; $ii++)

    5725. 

  5725.     {

    5726. 

  5726.         foreach ($a_ordered_headers[$ii] as $s_name=>$s_value)

    5727. 

  5727.             if ($s_name != "")

    5728. 

  5728.                 $a_hdrs[] = $s_name.": ".$s_value.HEAD_CRLF;

    5729. 

  5729.     }

    5730. 

  5730.     return ($a_hdrs);

    5731. 

  5731. }

    5732. 

  5732. 

    5733. 

  5733.     //

    5734. 

  5734.     // Low-level email send function; either calls PHP's mail function

    5735. 

  5735.     // or uses the PEAR Mail object.

    5736. 

  5736.     // NOTE: for some errors, there's no point trying to email

    5737. 

  5737.     // an alert message!  So, in these cases, we just display the error to

    5738. 

  5738.     // the user.

    5739. 

  5739.     // $s_options are ignored for PEAR sending.

    5740. 

  5740.     //

    5741. 

  5741. function DoMail($s_to,$s_subject,$s_mesg,$a_headers,$s_options)

    5742. 

  5742. {

    5743. 

  5743.     global  $PEAR_SMTP_HOST,$PEAR_SMTP_PORT,$PEAR_SMTP_USER,$PEAR_SMTP_PWD;

    5744. 

  5744. 

    5745. 

  5745.         //

    5746. 

  5746.         // Encode the subject line.

    5747. 

  5747.         // Ideally, we want to encode the relevant parts of To, From, Cc,

    5748. 

  5748.         // Reply-To, and this is the right place to do it.

    5749. 

  5749.         // However, it's another 1000 lines of code!

    5750. 

  5750.         // So, we must compromise the code quality because of this cost.

    5751. 

  5751.         // We encode subject here, and we encode the From line where it's

    5752. 

  5752.         // created.  The rest remain for a future version where code size

    5753. 

  5753.         // can be controlled.

    5754. 

  5754.         //

    5755. 

  5755.     $s_subject = EncodeHeaderText($s_subject);

    5756. 

  5756.     if (isset($PEAR_SMTP_HOST) && !empty($PEAR_SMTP_HOST))

    5757. 

  5757.     {

    5758. 

  5758.             //

    5759. 

  5759.             // Note that PEAR Mail seems to take responsibility for header line folding

    5760. 

  5760.             //

    5761. 

  5761.         require_once("Mail.php");

    5762. 

  5762. 

    5763. 

  5763.         $a_params = array(  "host"=>$PEAR_SMTP_HOST,

    5764. 

  5764.                             "port"=>$PEAR_SMTP_PORT);

    5765. 

  5765.         if (isset($PEAR_SMTP_USER) && !empty($PEAR_SMTP_USER))

    5766. 

  5766.         {

    5767. 

  5767.             $a_params["auth"] = TRUE;

    5768. 

  5768.             $a_params["username"] = $PEAR_SMTP_USER;

    5769. 

  5769.             $a_params["password"] = $PEAR_SMTP_PWD;

    5770. 

  5770.         }

    5771. 

  5771.         $mailer = Mail::factory("smtp",$a_params);

    5772. 

  5772.         if (!is_object($mailer))

    5773. 

  5773.         {

    5774. 

  5774.             ShowError("pear_error",GetMessage(MSG_PEAR_OBJ),FALSE,FALSE);

    5775. 

  5775.             exit;

    5776. 

  5776.         }

    5777. 

  5777.         if (strtolower(get_class($mailer)) === 'pear_error')

    5778. 

  5778.         {

    5779. 

  5779.             ShowError("pear_error",$mailer->getMessage(),FALSE,FALSE);

    5780. 

  5780.             exit;

    5781. 

  5781.         }

    5782. 

  5782.         if (!isset($a_headers['To']) && !isset($a_headers['to']))

    5783. 

  5783.             $a_headers['To'] = SafeHeader($s_to);

    5784. 

  5784.         if (!isset($a_headers['Subject']) && !isset($a_headers['subject']))

    5785. 

  5785.             $a_headers['Subject'] = SafeHeader($s_subject);

    5786. 

  5786.         $res = $mailer->send($s_to,$a_headers,$s_mesg);

    5787. 

  5787.         if ($res === TRUE)

    5788. 

  5788.             return (TRUE);

    5789. 

  5789. 

    5790. 

  5790.         global  $aAlertInfo;

    5791. 

  5791. 

    5792. 

  5792.         $aAlertInfo[] = GetMessage(MSG_PEAR_ERROR,array("MSG"=>$res->getMessage()));

    5793. 

  5793.         return (FALSE);

    5794. 

  5794.     }

    5795. 

  5795.     else

    5796. 

  5796.     {

    5797. 

  5797.         //$s_subject = HeaderFolding($s_subject,RFCLINELEN-10);   // "Subject: " is about 10 chars

    5798. 

  5798.             //

    5799. 

  5799.             // Notes from Feb 2010....

    5800. 

  5800.             //

    5801. 

  5801.             // PHP's mail function (tested in version 5.2.6) does folding of the

    5802. 

  5802.             // To line and the Subject line.

    5803. 

  5803.             // If we do it, then things break.

    5804. 

  5804.             //

    5805. 

  5805.             // This area is quite confusing.  It's not clear whether the script

    5806. 

  5806.             // should be folding header lines or whether the MTA should do it.

    5807. 

  5807.             // We *do know* (as stated above) that folding To and Subject breaks things.

    5808. 

  5808.             //

    5809. 

  5809.             // But folding other header lines properly, seems to be OK.

    5810. 

  5810.             //

    5811. 

  5811.             // However, for years FormMail never did header line folding (except for the

    5812. 

  5812.             // soft line breaks inserted by the quoted_printable_encode function we had used),

    5813. 

  5813.             // and we didn't seem to get any reports of breakage (except for problems

    5814. 

  5814.             // with the quoted_printable_encode soft line breaks!).

    5815. 

  5815.             //

    5816. 

  5816.             // So, even though we've implemented all the code for header line folding,

    5817. 

  5817.             // we'll not use it.

    5818. 

  5818.             // No header line folding will be performed in version 8.22 onwards.

    5819. 

  5819.             //

    5820. 

  5820.         if ($s_options !== "")

    5821. 

  5821.             return (mail($s_to,$s_subject,$s_mesg,ExpandMailHeaders($a_headers),$s_options));

    5822. 

  5822.         else

    5823. 

  5823.             return (mail($s_to,$s_subject,$s_mesg,ExpandMailHeaders($a_headers)));

    5824. 

  5824.     }

    5825. 

  5825. }

    5826. 

  5826. 

    5827. 

  5827.     //

    5828. 

  5828.     // Send an email

    5829. 

  5829.     //

    5830. 

  5830. function SendCheckedMail($to,$subject,$mesg,$sender,$a_headers = array())

    5831. 

  5831. {

    5832. 

  5832.     global  $PEAR_SMTP_HOST;

    5833. 

  5833. 

    5834. 

  5834.     $b_f_option = false;

    5835. 

  5835.     $b_form_option = IsMailOptionSet("SendMailFOption");    // this is superseded, but still supported

    5836. 

  5836.     if (SENDMAIL_F_OPTION || $b_form_option)

    5837. 

  5837.     {

    5838. 

  5838.         if (empty($sender))

    5839. 

  5839.         {

    5840. 

  5840.                 //

    5841. 

  5841.                 // SENDMAIL_F_OPTION with no sender is silently ignored

    5842. 

  5842.                 //

    5843. 

  5843.             if ($b_form_option)

    5844. 

  5844.             {

    5845. 

  5845.                     //

    5846. 

  5846.                     // form has specified SendMailFOption, but there's no

    5847. 

  5847.                     // sender address

    5848. 

  5848.                     //

    5849. 

  5849.                 static  $b_in_here = false;

    5850. 

  5850.                 global  $SERVER;

    5851. 

  5851. 

    5852. 

  5852.                 if (!$b_in_here)        // prevent infinite recursion

    5853. 

  5853.                 {

    5854. 

  5854.                     $b_in_here = true;

    5855. 

  5855.                     SendAlert(GetMessage(MSG_NO_FOPT_ADDR));

    5856. 

  5856.                     $b_in_here = false;

    5857. 

  5857.                 }

    5858. 

  5858.                     //

    5859. 

  5859.                     // if there's no from address, create a dummy one

    5860. 

  5860.                     //

    5861. 

  5861.                 $sender = "dummy@".(isset($SERVER) ? $SERVER : "UnknownServer");

    5862. 

  5862.                 $a_headers['From'] = $sender;

    5863. 

  5863.                 $b_f_option = true;

    5864. 

  5864.             }

    5865. 

  5865.         }

    5866. 

  5866.         else

    5867. 

  5867.             $b_f_option = true;

    5868. 

  5868.     }

    5869. 

  5869.     if (INI_SET_FROM && !empty($sender))

    5870. 

  5870.         ini_set('sendmail_from',$sender);

    5871. 

  5871. 

    5872. 

  5872.     return (DoMail($to,$subject,$mesg,$a_headers,($b_f_option ? "-f$sender" : "")));

    5873. 

  5873. }

    5874. 

  5874. 

    5875. 

  5875.     //

    5876. 

  5876.     // Send an alert email

    5877. 

  5877.     //

    5878. 

  5878. function SendAlert($s_error,$b_filter = true,$b_non_error = false)

    5879. 

  5879. {

    5880. 

  5880.     global  $SPECIAL_VALUES,$FORMATTED_INPUT,$FROM_USER,$aServerVars,$aStrippedFormVars;

    5881. 

  5881.     global  $aAlertInfo,$aCleanedValues,$aFieldOrder,$sHTMLCharSet;

    5882. 

  5882. 

    5883. 

  5883.     $s_error = str_replace("\n",BODY_LF,$s_error);

    5884. 

  5884.     $b_got_filter = GetFilterSpec($s_filter_name,$a_filter_list);

    5885. 

  5885. 

    5886. 

  5886.         //

    5887. 

  5887.         // if there is a filter specified and we're not sending the alert

    5888. 

  5888.         // through the filter, don't show the user's data.  This is

    5889. 

  5889.         // on the assumption that the filter is an encryption program; so,

    5890. 

  5890.         // we don't want to send the user's data in clear text inside the

    5891. 

  5891.         // alerts.

    5892. 

  5892.         //

    5893. 

  5893.     $b_show_data = true;

    5894. 

  5894.     if ($b_got_filter && !$b_filter)

    5895. 

  5895.         $b_show_data = false;

    5896. 

  5896. 

    5897. 

  5897.     $s_form_subject = $s_alert_to = "";

    5898. 

  5898.     $b_check = true;

    5899. 

  5899.         //

    5900. 

  5900.         // might be too early to have $SPECIAL_VALUES set, so

    5901. 

  5901.         // look in the form vars too

    5902. 

  5902.         //

    5903. 

  5903.     if (isset($SPECIAL_VALUES["alert_to"]))

    5904. 

  5904.         $s_alert_to = trim($SPECIAL_VALUES["alert_to"]);

    5905. 

  5905.     if (empty($s_alert_to) && isset($aStrippedFormVars["alert_to"]))

    5906. 

  5906.         $s_alert_to = trim($aStrippedFormVars["alert_to"]);

    5907. 

  5907. 

    5908. 

  5908.     if (isset($SPECIAL_VALUES["subject"]))

    5909. 

  5909.         $s_form_subject = trim($SPECIAL_VALUES["subject"]);

    5910. 

  5910.     if (empty($s_form_subject) && isset($aStrippedFormVars["subject"]))

    5911. 

  5911.         $s_form_subject = trim($aStrippedFormVars["subject"]);

    5912. 

  5912. 

    5913. 

  5913.     if (empty($s_alert_to))

    5914. 

  5914.     {

    5915. 

  5915.         $s_alert_to = DEF_ALERT;

    5916. 

  5916.         $b_check = false;

    5917. 

  5917.     }

    5918. 

  5918.     if (!empty($s_alert_to))

    5919. 

  5919.     {

    5920. 

  5920.         $s_from_addr = $s_from = "";

    5921. 

  5921.         $a_headers = array();

    5922. 

  5922.         if (isset($FROM_USER) && !empty($FROM_USER))

    5923. 

  5923.         {

    5924. 

  5924.             if ($FROM_USER != "NONE")

    5925. 

  5925.             {

    5926. 

  5926.                 $a_headers['From'] = $FROM_USER;

    5927. 

  5927.                 $s_from = "From: $FROM_USER";

    5928. 

  5928.                 $s_from_addr = $FROM_USER;

    5929. 

  5929.             }

    5930. 

  5930.         }

    5931. 

  5931.         else

    5932. 

  5932.         {

    5933. 

  5933.             global  $SERVER;

    5934. 

  5934. 

    5935. 

  5935.             $s_from_addr = "FormMail@".$SERVER;

    5936. 

  5936.             $a_headers['From'] = $s_from_addr;

    5937. 

  5937.             $s_from = "From: $s_from_addr";

    5938. 

  5938.         }

    5939. 

  5939.         $s_mesg = "To: ".UnMangle($s_alert_to).BODY_LF;

    5940. 

  5940.             //

    5941. 

  5941.             // if a language pack has been included, a lot of error messages

    5942. 

  5942.             // may need the character set to be provided.

    5943. 

  5943.             // If that's available from the language pack, use it,

    5944. 

  5944.             // otherwise, if it's a mail_option, use it from there.

    5945. 

  5945.             //

    5946. 

  5946.         $s_charset = "";

    5947. 

  5947.         if (isset($sHTMLCharSet) && $sHTMLCharSet !== "")

    5948. 

  5948.             $s_charset = $sHTMLCharSet;

    5949. 

  5949.         else if (IsMailOptionSet("CharSet"))

    5950. 

  5950.             $s_charset = GetMailOption("CharSet");

    5951. 

  5951. 

    5952. 

  5952.             //

    5953. 

  5953.             // Alerts are plain text emails, so convert any HTML entities

    5954. 

  5954.             // back to their original characters.  Note, this will only work on PHP

    5955. 

  5955.             // version 4.3.0 and above.

    5956. 

  5956.             //

    5957. 

  5957.         if (function_exists("html_entity_decode"))

    5958. 

  5958.             $s_error = @html_entity_decode($s_error,ENT_COMPAT,$s_charset);

    5959. 

  5959. 

    5960. 

  5960.         if ($s_charset !== "")

    5961. 

  5961.             $a_headers['Content-Type'] = SafeHeader("text/plain; charset=$s_charset");

    5962. 

  5962. 

    5963. 

  5963.         if (!empty($s_from))

    5964. 

  5964.             $s_mesg .= $s_from.BODY_LF;

    5965. 

  5965.         $s_mesg .= BODY_LF;

    5966. 

  5966.         if (count($aAlertInfo) > 0)

    5967. 

  5967.         {

    5968. 

  5968.             if ($b_show_data)

    5969. 

  5969.             {

    5970. 

  5970.                 $s_error .= BODY_LF.GetMessage(MSG_MORE_INFO).BODY_LF;

    5971. 

  5971.                 $s_error .= implode(BODY_LF,$aAlertInfo);

    5972. 

  5972.             }

    5973. 

  5973.             else

    5974. 

  5974.                 $s_error .= BODY_LF.GetMessage(MSG_INFO_STOPPED).BODY_LF;

    5975. 

  5975.         }

    5976. 

  5976.             //

    5977. 

  5977.             // some fields aren't security issues - show those in the alert

    5978. 

  5978.             //

    5979. 

  5979.         $a_safe_fields = array(

    5980. 

  5980.                     "email: ".$SPECIAL_VALUES["email"],

    5981. 

  5981.                     "realname: ".$SPECIAL_VALUES["realname"],

    5982. 

  5982.                         );

    5983. 

  5983.         $s_safe_data = implode(BODY_LF,$a_safe_fields);

    5984. 

  5984. 

    5985. 

  5985.         if ($b_non_error)

    5986. 

  5986.         {

    5987. 

  5987.             $s_preamble = $s_error.BODY_LF.BODY_LF;

    5988. 

  5988.             $s_mesg .= $s_preamble;

    5989. 

  5989.             $s_subj = GetMessage(MSG_FM_ALERT);

    5990. 

  5990.             if (!empty($s_form_subject))

    5991. 

  5991.                 $s_subj .= " ($s_form_subject)";

    5992. 

  5992.         }

    5993. 

  5993.         else

    5994. 

  5994.         {

    5995. 

  5995.             $s_preamble = GetMessage(MSG_FM_ERROR_LINE).BODY_LF.

    5996. 

  5996.                             $s_error.BODY_LF.BODY_LF;

    5997. 

  5997.             $s_mesg .= $s_preamble;

    5998. 

  5998.             $s_subj = GetMessage(MSG_FM_ERROR);

    5999. 

  5999.             if (!empty($s_form_subject))

    6000. 

  6000.                 $s_subj .= " ($s_form_subject)";

    6001. 

  6001.             $s_mesg .= $s_safe_data;

    6002. 

  6002.             $s_mesg .= BODY_LF.BODY_LF;

    6003. 

  6003.             if ($b_show_data)

    6004. 

  6004.                 $s_mesg .= implode(BODY_LF,$FORMATTED_INPUT);

    6005. 

  6005.             else

    6006. 

  6006.                 $s_mesg .= GetMessage(MSG_USERDATA_STOPPED);

    6007. 

  6007.         }

    6008. 

  6008.             

    6009. 

  6009.             /*

    6010. 

  6010.              * We only need to filter the form fields if the filter that

    6011. 

  6011.              * is specified is an encrypting filter.

    6012. 

  6012.              */

    6013. 

  6013.         if ($b_filter && $b_got_filter &&

    6014. 

  6014.                 IsFilterAttribSet($SPECIAL_VALUES["filter"],"Encrypts"))

    6015. 

  6015.         {

    6016. 

  6016.             $s_new_mesg = $s_preamble.$s_safe_data;

    6017. 

  6017.             $s_new_mesg .= BODY_LF.BODY_LF;

    6018. 

  6018. 

    6019. 

  6019.             if ($a_filter_list !== false)

    6020. 

  6020.             {

    6021. 

  6021.                     //

    6022. 

  6022.                     // just filter the critical fields

    6023. 

  6023.                     //

    6024. 

  6024.                 list($s_unfiltered,$s_filtered_results) =

    6025. 

  6025.                             GetFilteredOutput($aFieldOrder,$aCleanedValues,

    6026. 

  6026.                                     $s_filter_name,$a_filter_list);

    6027. 

  6027.                 $s_new_mesg .= $s_unfiltered;

    6028. 

  6028.             }

    6029. 

  6029.             else

    6030. 

  6030.             {

    6031. 

  6031.                     //

    6032. 

  6032.                     // filter everything

    6033. 

  6033.                     //

    6034. 

  6034.                 $s_filtered_results = Filter($s_filter_name,$s_mesg);

    6035. 

  6035.             }

    6036. 

  6036.             $s_new_mesg .= GetMessage(MSG_FILTERED,array("FILTER"=>$s_filter_name)).

    6037. 

  6037.                             BODY_LF.BODY_LF.

    6038. 

  6038.                             $s_filtered_results;

    6039. 

  6039.             $s_mesg = $s_new_mesg;

    6040. 

  6040.         }

    6041. 

  6041.         $s_mesg .= BODY_LF;

    6042. 

  6042. 

    6043. 

  6043.         if (isset($aServerVars['HTTP_REFERER']))

    6044. 

  6044.             $s_mesg .= "Referring page was ".$aServerVars['HTTP_REFERER'];

    6045. 

  6045.         elseif (isset($SPECIAL_VALUES['this_form']) && $SPECIAL_VALUES['this_form'] !== "")

    6046. 

  6046.             $s_mesg .= "Referring form was ".$SPECIAL_VALUES['this_form'];

    6047. 

  6047. 

    6048. 

  6048.         $s_mesg .= BODY_LF;

    6049. 

  6049. 

    6050. 

  6050.         if (isset($aServerVars['SERVER_NAME']))

    6051. 

  6051.             $s_mesg .= "SERVER_NAME was ".$aServerVars['SERVER_NAME'].BODY_LF;

    6052. 

  6052.         if (isset($aServerVars['REQUEST_URI']))

    6053. 

  6053.             $s_mesg .= "REQUEST_URI was ".$aServerVars['REQUEST_URI'].BODY_LF;

    6054. 

  6054. 

    6055. 

  6055.         $s_mesg .= BODY_LF;

    6056. 

  6056. 

    6057. 

  6057.         if (isset($aServerVars['REMOTE_ADDR']))

    6058. 

  6058.             $s_mesg .= "User IP address was ".$aServerVars['REMOTE_ADDR'].BODY_LF;

    6059. 

  6059.         if (isset($aServerVars['HTTP_USER_AGENT']))

    6060. 

  6060.             $s_mesg .= "User agent was ".$aServerVars['HTTP_USER_AGENT'].BODY_LF;

    6061. 

  6061. 

    6062. 

  6062.         if ($b_check)

    6063. 

  6063.         {

    6064. 

  6064.             if (CheckEmailAddress($s_alert_to,$s_valid,$s_invalid))

    6065. 

  6065.                 return (SendCheckedMail($s_valid,$s_subj,$s_mesg,$s_from_addr,$a_headers));

    6066. 

  6066.         }

    6067. 

  6067.         else

    6068. 

  6068.             return (SendCheckedMail($s_alert_to,$s_subj,$s_mesg,$s_from_addr,$a_headers));

    6069. 

  6069.     }

    6070. 

  6070.     return (false);

    6071. 

  6071. }

    6072. 

  6072. 

    6073. 

  6073.     //

    6074. 

  6074.     // Read the lines in a file and return an array.

    6075. 

  6075.     // Each line is stripped of line termination characters.

    6076. 

  6076.     //

    6077. 

  6077. function ReadLines($fp)

    6078. 

  6078. {

    6079. 

  6079.     $a_lines = array();

    6080. 

  6080.     while (!feof($fp))

    6081. 

  6081.     {

    6082. 

  6082.         $s_line = fgets($fp,4096);

    6083. 

  6083.             //

    6084. 

  6084.             // strip carriage returns and line feeds

    6085. 

  6085.             //

    6086. 

  6086.         $s_line = str_replace("\r","",$s_line);

    6087. 

  6087.         $s_line = str_replace("\n","",$s_line);

    6088. 

  6088.         $a_lines[] = $s_line;

    6089. 

  6089.     }

    6090. 

  6090.     return ($a_lines);

    6091. 

  6091. }

    6092. 

  6092. 

    6093. 

  6093.     //

    6094. 

  6094.     // Open a URL and return the data from it as a string or array of lines.

    6095. 

  6095.     // Returns false on failure ($s_error has the error string)

    6096. 

  6096.     //

    6097. 

  6097. function GetURL($s_url,&$s_error,$b_ret_lines = false,$n_depth = 0)

    6098. 

  6098. {

    6099. 

  6099.     global  $php_errormsg,$aServerVars,$sUserAgent;

    6100. 

  6100.     global  $AUTHENTICATE,$AUTH_USER,$AUTH_PW;

    6101. 

  6101. 

    6102. 

  6102.         //

    6103. 

  6103.         // open the URL with the same session as we have

    6104. 

  6104.         //

    6105. 

  6105.     if (session_id() !== "")

    6106. 

  6106.         $s_url = AddURLParams($s_url,session_name()."=".urlencode(session_id()));

    6107. 

  6107.     if (defined("SID"))

    6108. 

  6108.         $s_url = AddURLParams($s_url,SID);

    6109. 

  6109. 

    6110. 

  6110.     $http_get = new HTTPGet($s_url);

    6111. 

  6111. 

    6112. 

  6112.         //

    6113. 

  6113.         // Determine authentication requirements

    6114. 

  6114.         //

    6115. 

  6115.     if ($AUTHENTICATE !== "" || $AUTH_USER !== "" || $AUTH_PW !== "")

    6116. 

  6116.     {

    6117. 

  6117.         if ($AUTHENTICATE === "")

    6118. 

  6118.             $http_get->SetAuthentication("Basic",$AUTH_USER,$AUTH_PW);

    6119. 

  6119.         else

    6120. 

  6120.             $http_get->SetAuthenticationLine($AUTHENTICATE);

    6121. 

  6121.     }

    6122. 

  6122.     else

    6123. 

  6123.     {

    6124. 

  6124.         $a_parts = $http_get->GetURLSplit();

    6125. 

  6125.         if (isset($a_parts["user"]) || isset($a_parts["pass"]))

    6126. 

  6126.         {

    6127. 

  6127.             $s_auth_user = isset($a_parts["user"]) ? $a_parts["user"] : "";

    6128. 

  6128.             $s_auth_pass = isset($a_parts["pass"]) ? $a_parts["pass"] : "";

    6129. 

  6129.         }

    6130. 

  6130.         else

    6131. 

  6131.         {

    6132. 

  6132.             $s_auth_type = isset($aServerVars["PHP_AUTH_TYPE"]) ? $aServerVars["PHP_AUTH_TYPE"] : "";

    6133. 

  6133.             $s_auth_user = isset($aServerVars["PHP_AUTH_USER"]) ? $aServerVars["PHP_AUTH_USER"] : "";

    6134. 

  6134.             $s_auth_pass = isset($aServerVars["PHP_AUTH_PW"]) ? $aServerVars["PHP_AUTH_PW"] : "";

    6135. 

  6135.         }

    6136. 

  6136.         if (!isset($s_auth_type) || $s_auth_type === "")

    6137. 

  6137.             $s_auth_type = "Basic";

    6138. 

  6138.         if ($s_auth_user !== "" || $s_auth_pass !== "")

    6139. 

  6139.             $http_get->SetAuthentication($s_auth_type,$s_auth_user,$s_auth_pass);

    6140. 

  6140.     }

    6141. 

  6141.         //

    6142. 

  6142.         // set the user agent

    6143. 

  6143.         //

    6144. 

  6144.     $http_get->SetAgent($sUserAgent);

    6145. 

  6145.         //

    6146. 

  6146.         // resolve the name now so the DNS cache can be written to the session

    6147. 

  6147.         //

    6148. 

  6148.     $http_get->Resolve();

    6149. 

  6149. 

    6150. 

  6150.         //

    6151. 

  6151.         // Since we might be opening a URL within the same session, we can

    6152. 

  6152.         // get locks.  So, close the session for writing to prevent this.

    6153. 

  6153.         //

    6154. 

  6154.     $b_closed = false;

    6155. 

  6155.     if (function_exists('session_write_close'))

    6156. 

  6156.     {

    6157. 

  6157.         session_write_close();

    6158. 

  6158.         $b_closed = true;

    6159. 

  6159.         //ob_flush();             // this prevents automatic redirects if $TEMPLATEURL

    6160. 

  6160.                                   // is in use and JavaScript is switched off

    6161. 

  6161.     }

    6162. 

  6162. 

    6163. 

  6163.     $m_buf = FALSE;

    6164. 

  6164. 

    6165. 

  6165.     //FMDebug("Begin read");

    6166. 

  6166.     if (($a_lines = $http_get->Read()) === FALSE)

    6167. 

  6167.     {

    6168. 

  6168.         $http_get->Close();

    6169. 

  6169.             //

    6170. 

  6170.             // get the error code and send the appropriate alert

    6171. 

  6171.             //

    6172. 

  6172.         list($i_error,$i_sys_err,$s_sys_msg) = $http_get->GetError();

    6173. 

  6173.         switch ($i_error)

    6174. 

  6174.         {

    6175. 

  6175.         case $http_get->nErrParse:

    6176. 

  6176.             $s_error = GetMessage(MSG_URL_PARSE);

    6177. 

  6177.             break;

    6178. 

  6178.         case $http_get->nErrScheme:

    6179. 

  6179.             $a_parts = $http_get->GetURLSplit();

    6180. 

  6180.             $s_error = GetMessage(MSG_URL_SCHEME,array("SCHEME"=>$a_parts["scheme"]));

    6181. 

  6181.             break;

    6182. 

  6182.         default:

    6183. 

  6183.             $s_error = GetMessage(MSG_SOCKET,

    6184. 

  6184.                             array("ERRNO"=>$i_sys_err,

    6185. 

  6185.                                 "ERRSTR"=>$s_sys_msg,

    6186. 

  6186.                                 "PHPERR"=>isset($php_errormsg) ? $php_errormsg : ""));

    6187. 

  6187.             break;

    6188. 

  6188.         }

    6189. 

  6189.     }

    6190. 

  6190.     else

    6191. 

  6191.     {

    6192. 

  6192.         $http_get->Close();

    6193. 

  6193.             //

    6194. 

  6194.             // check the HTTP response for actual status.  Anything outside

    6195. 

  6195.             // 200-299 is a failure, but we also handle redirects.

    6196. 

  6196.             //

    6197. 

  6197.         list($i_http_code,$s_http_status) = $http_get->GetHTTPStatus();

    6198. 

  6198. 

    6199. 

  6199.         if ($i_http_code < 200 || $i_http_code > 299)

    6200. 

  6200.         {

    6201. 

  6201.             switch ($i_http_code)

    6202. 

  6202.             {

    6203. 

  6203.             case 300:       // multiple choices (we'll take the first)

    6204. 

  6204.             case 301:       // moved permanently

    6205. 

  6205.             case 302:       // found

    6206. 

  6206.             case 303:       // see other

    6207. 

  6207.             case 307:       // temporary redirect

    6208. 

  6208.                     //

    6209. 

  6209.                     // a "location" header must be present for us to continue

    6210. 

  6210.                     // In the case of infinite redirects, we need to stop.

    6211. 

  6211.                     // So, we limit to a maximum of 10 redirects.

    6212. 

  6212.                     //

    6213. 

  6213.                 if ($n_depth < 10)

    6214. 

  6214.                 {

    6215. 

  6215.                     if (($s_location = $http_get->FindHeader("location")) !== false)

    6216. 

  6216.                     {

    6217. 

  6217.                         FMDebug("Redirect from '$s_url' to '$s_location'");

    6218. 

  6218.                         $m_buf = GetURL($s_location,$s_error,$b_ret_lines,$n_depth+1);

    6219. 

  6219.                         $b_closed = false;

    6220. 

  6220.                         break;

    6221. 

  6221.                     }

    6222. 

  6222.                     FMDebug("Redirect FAILED - no location header");

    6223. 

  6223.                 }

    6224. 

  6224.                 else

    6225. 

  6225.                     FMDebug("Redirect FAILED depth=$n_depth");

    6226. 

  6226.                 // FALL THRU

    6227. 

  6227.             default:

    6228. 

  6228.                 $s_error = GetMessage(MSG_GETURL_OPEN,array("STATUS"=>$s_http_status));

    6229. 

  6229.                 break;

    6230. 

  6230.             }

    6231. 

  6231.         }

    6232. 

  6232.         elseif ($b_ret_lines)

    6233. 

  6233.             $m_buf = $a_lines;

    6234. 

  6234.         else

    6235. 

  6235.                 //

    6236. 

  6236.                 // return lines as one big string buffer

    6237. 

  6237.                 //

    6238. 

  6238.             $m_buf = implode("",$a_lines);

    6239. 

  6239.     }

    6240. 

  6240.         //

    6241. 

  6241.         // re-open our session

    6242. 

  6242.         //

    6243. 

  6243.     if ($b_closed)

    6244. 

  6244.         session_start();

    6245. 

  6245. 

    6246. 

  6246.     return ($m_buf);

    6247. 

  6247. }

    6248. 

  6248. 

    6249. 

  6249. 

    6250. 

  6250. //

    6251. 

  6251. // Write to the debug log if it exists and is writable.

    6252. 

  6252. //

    6253. 

  6253. function    FMDebug($s_mesg)

    6254. 

  6254. {

    6255. 

  6255.     static  $fDebug = NULL;

    6256. 

  6256. 

    6257. 

  6257.     if (!isset($fDebug))

    6258. 

  6258.     {

    6259. 

  6259.         $fDebug = false;        // only initialize once

    6260. 

  6260.         $s_dir = GetTempDir();  // look for the debug log file in the temp directory

    6261. 

  6261.         $s_db_file = "$s_dir/fmdebug.log";

    6262. 

  6262.             //

    6263. 

  6263.             // we only open an existing file - we don't create one

    6264. 

  6264.             //

    6265. 

  6265.         if (file_exists($s_db_file))

    6266. 

  6266.             if (($fDebug = fopen($s_db_file,"a")) === false)

    6267. 

  6267.                 return;

    6268. 

  6268.     }

    6269. 

  6269.     if ($fDebug !== false)

    6270. 

  6270.     {

    6271. 

  6271.         fwrite($fDebug,date('r').": ".$s_mesg."\n");

    6272. 

  6272.         fflush($fDebug);

    6273. 

  6273.     }

    6274. 

  6274. }

    6275. 

  6275. 

    6276. 

  6276. /*

    6277. 

  6277.  * Class:       NetIO

    6278. 

  6278.  * Description:     

    6279. 

  6279.  *  A class to provide internet input/output capabilities.

    6280. 

  6280.  *  Use as a base class for more specific functions.

    6281. 

  6281.  */

    6282. 

  6282. class   NetIO

    6283. 

  6283. {

    6284. 

  6284.     var     $_sHost;

    6285. 

  6285.     var     $_iPort;

    6286. 

  6286.     var     $_sPrefix;

    6287. 

  6287. 

    6288. 

  6288.     var     $_iConnTimeout;

    6289. 

  6289.     var     $_fSock;

    6290. 

  6290. 

    6291. 

  6291.     var     $_aIPs;

    6292. 

  6292. 

    6293. 

  6293.     var     $_iError = 0;

    6294. 

  6294.     var     $_iSysErr;

    6295. 

  6295.     var     $_sSysMesg;

    6296. 

  6296. 

    6297. 

  6297.     var     $nErrInit =     -1;      // not initialized

    6298. 

  6298.     var     $nErrRead =     -2;      // read error

    6299. 

  6299.     var     $nErrWrite =    -3;      // write error

    6300. 

  6300.     var     $nErrWriteShort = -4;    // failed to write all bytes

    6301. 

  6301. 

    6302. 

  6302.     var     $nErrSocket =   -100;    // error in socket open

    6303. 

  6303. 

    6304. 

  6304.     function    NetIO($s_host = NULL,$i_port = NULL,$s_prefix = "")

    6305. 

  6305.     {

    6306. 

  6306.         if (isset($s_host))

    6307. 

  6307.             $this->_sHost = $s_host;

    6308. 

  6308.         if (isset($i_port))

    6309. 

  6309.             $this->_iPort = $i_port;

    6310. 

  6310.         $this->_sPrefix = $s_prefix;

    6311. 

  6311.         $this->_iConnTimeout = 30;

    6312. 

  6312.         $this->_iSysErr = 0;

    6313. 

  6313.         $this->_sSysMesg = "";

    6314. 

  6314.     }

    6315. 

  6315. 

    6316. 

  6316.     function    _SetError($i_error,$i_sys_err = 0,$s_sys_mesg = "")

    6317. 

  6317.     {

    6318. 

  6318.         $this->_iError = $i_error;

    6319. 

  6319.         $this->_iSysErr = $i_sys_err;

    6320. 

  6320.         $this->_sSysMesg = $s_sys_mesg;

    6321. 

  6321.         return (FALSE);

    6322. 

  6322.     }

    6323. 

  6323. 

    6324. 

  6324.     function    IsError()

    6325. 

  6325.     {

    6326. 

  6326.         return ($this->_iError != 0 ? TRUE : FALSE);

    6327. 

  6327.     }

    6328. 

  6328. 

    6329. 

  6329.     function    ClearError()

    6330. 

  6330.     {

    6331. 

  6331.         $this->_SetError(0);

    6332. 

  6332.     }

    6333. 

  6333. 

    6334. 

  6334.     function    GetError()

    6335. 

  6335.     {

    6336. 

  6336.         return (array($this->_iError,$this->_iSysErr,$this->_sSysMesg));

    6337. 

  6337.     }

    6338. 

  6338. 

    6339. 

  6339.     function    SetHost($s_host)

    6340. 

  6340.     {

    6341. 

  6341.         $this->_sHost = $s_host;

    6342. 

  6342.     }

    6343. 

  6343. 

    6344. 

  6344.     function    SetPort($i_port)

    6345. 

  6345.     {

    6346. 

  6346.         $this->_iPort = $i_port;

    6347. 

  6347.     }

    6348. 

  6348. 

    6349. 

  6349.     function    SetConnectionTimeout($i_secs)

    6350. 

  6350.     {

    6351. 

  6351.         $this->_iConnTimeout = $i_secs;

    6352. 

  6352.     }

    6353. 

  6353. 

    6354. 

  6354.     function    SetPrefix($s_prefix)

    6355. 

  6355.     {

    6356. 

  6356.         $this->_sPrefix = $s_prefix;

    6357. 

  6357.     }

    6358. 

  6358. 

    6359. 

  6359.     function    GetHost()

    6360. 

  6360.     {

    6361. 

  6361.         return (isset($this->_sHost) ? $this->_sHost : "");

    6362. 

  6362.     }

    6363. 

  6363. 

    6364. 

  6364.     function    GetPort()

    6365. 

  6365.     {

    6366. 

  6366.         return (isset($this->_iPort) ? $this->_iPort : 0);

    6367. 

  6367.     }

    6368. 

  6368. 

    6369. 

  6369.     function    GetPrefix()

    6370. 

  6370.     {

    6371. 

  6371.         return ($this->_sPrefix);

    6372. 

  6372.     }

    6373. 

  6373. 

    6374. 

  6374.     function    GetConnectionTimeout()

    6375. 

  6375.     {

    6376. 

  6376.         return ($this->_iConnTimeout);

    6377. 

  6377.     }

    6378. 

  6378. 

    6379. 

  6379.     function    _CacheIt()

    6380. 

  6380.     {

    6381. 

  6381.         FMDebug("Caching ".implode(",",$this->_aIPs));

    6382. 

  6382.         if (IsSetSession("FormNetIODNSCache"))

    6383. 

  6383.             $a_cache = GetSession("FormNetIODNSCache");

    6384. 

  6384.         else

    6385. 

  6385.             $a_cache = array();

    6386. 

  6386.         $a_cache[$this->_sHost] = $this->_aIPs;

    6387. 

  6387.         SetSession("FormNetIODNSCache",$a_cache);

    6388. 

  6388.     }

    6389. 

  6389. 

    6390. 

  6390.     /*

    6391. 

  6391.      * Some versions of PHP seem to have a major slowdown when resolving

    6392. 

  6392.      * names with gethostbyname (5 seconds with PHP 4.3.9).

    6393. 

  6393.      * So, in the case of multi-page forms using MULTIFORMURL, we get a big speed up

    6394. 

  6394.      * by caching the IP address of the server.

    6395. 

  6395.      */

    6396. 

  6396.     function    _CheckCache()

    6397. 

  6397.     {

    6398. 

  6398.         if (!IsSetSession("FormNetIODNSCache"))

    6399. 

  6399.             return (FALSE);

    6400. 

  6400.         $a_cache = GetSession("FormNetIODNSCache");

    6401. 

  6401.         if (!is_array($a_cache) || !isset($a_cache[$this->_sHost]) || !is_array($a_cache[$this->_sHost]))

    6402. 

  6402.             return (FALSE);

    6403. 

  6403.         $this->_aIPs = $a_cache[$this->_sHost];

    6404. 

  6404.         return (TRUE);

    6405. 

  6405.     }

    6406. 

  6406. 

    6407. 

  6407.     function    Resolve()

    6408. 

  6408.     {

    6409. 

  6409.         $this->ClearError();

    6410. 

  6410.         if (!isset($this->_sHost))

    6411. 

  6411.             return ($this->_SetError($this->nErrInit));

    6412. 

  6412.         if ($this->_CheckCache())

    6413. 

  6413.             return (TRUE);

    6414. 

  6414.         FMDebug("Start resolve of ".$this->_sHost);

    6415. 

  6415.             //

    6416. 

  6416.             // if host is an actual IP address, then it is returned unchanged, which is good!

    6417. 

  6417.             //

    6418. 

  6418.         if (($a_ip_list = gethostbynamel($this->_sHost)) === FALSE)

    6419. 

  6419.         {

    6420. 

  6420.             FMDebug("Resolve failed");

    6421. 

  6421.             return ($this->_SetError($this->nErrInit,0,

    6422. 

  6422.                     GetMessage(MSG_RESOLVE,array("NAME"=>$this->_sHost))));

    6423. 

  6423.         }

    6424. 

  6424.         FMDebug("Done resolve: ".implode(",",$a_ip_list));

    6425. 

  6425.         $this->_aIPs = $a_ip_list;

    6426. 

  6426.         $this->_CacheIt();

    6427. 

  6427.         return (TRUE);

    6428. 

  6428.     }

    6429. 

  6429. 

    6430. 

  6430.     function    _SSLOpen($s_ip,&$errno,&$errstr,$i_timeout)

    6431. 

  6431.     {

    6432. 

  6432.         FMDebug("Using _SSLOpen (stream_socket_client), SNI, host=".$this->GetHost());

    6433. 

  6433.         $context = stream_context_create();

    6434. 

  6434.         $result = stream_context_set_option($context,'ssl','verify_host',true);

    6435. 

  6435.         $result = stream_context_set_option($context,'ssl','verify_peer',false);

    6436. 

  6436.         $result = stream_context_set_option($context,'ssl','allow_self_signed',true);

    6437. 

  6437.         $result = stream_context_set_option($context,'ssl','SNI_enabled',true);

    6438. 

  6438.         $result = stream_context_set_option($context,'ssl','SNI_server_name',$this->GetHost());

    6439. 

  6439.             //

    6440. 

  6440.             // Note that even if SNI fails, the socket will still open, but the

    6441. 

  6441.             // web server should send a 400 error.

    6442. 

  6442.             //

    6443. 

  6443.         return (stream_socket_client($this->GetPrefix().$s_ip.":".$this->GetPort(),

    6444. 

  6444.                     $errno,$errstr,$i_timeout,STREAM_CLIENT_CONNECT,$context));

    6445. 

  6445.     }

    6446. 

  6446. 

    6447. 

  6447.     function    Open()

    6448. 

  6448.     {

    6449. 

  6449.         $this->ClearError();

    6450. 

  6450.         if (!isset($this->_sHost) || !isset($this->_iPort))

    6451. 

  6451.             return ($this->_SetError($this->nErrInit));

    6452. 

  6452.         if (!$this->Resolve())

    6453. 

  6453.             return (FALSE);

    6454. 

  6454.         FMDebug("Starting socket open");

    6455. 

  6455.         $f_sock = FALSE;

    6456. 

  6456.             //

    6457. 

  6457.             // Now, run through the list of IPs until we find one that connects.

    6458. 

  6458.             // However, this can cause problems with SNI in SSL/TLS connections.

    6459. 

  6459.             // If there is only one IP address, use the host name.

    6460. 

  6460.             // Otherwise, if we can specify SNI and it's an SSL connection

    6461. 

  6461.             // use streams, otherwise try each IP individually.

    6462. 

  6462.             //

    6463. 

  6463.         if (count($this->_aIPs) == 1)

    6464. 

  6464.         {

    6465. 

  6465.             FMDebug("Trying host ".$this->_sHost.", timeout ".$this->GetConnectionTimeout());

    6466. 

  6466.             $f_sock = @fsockopen($this->GetPrefix().$this->_sHost,$this->GetPort(),

    6467. 

  6467.                                     $errno,$errstr,$this->GetConnectionTimeout());

    6468. 

  6468.         }

    6469. 

  6469.         else

    6470. 

  6470.         {

    6471. 

  6471.             foreach ($this->_aIPs as $s_ip)

    6472. 

  6472.             {

    6473. 

  6473.                 FMDebug("Trying IP $s_ip, timeout ".$this->GetConnectionTimeout());

    6474. 

  6474.                 if (IsPHPAtLeast("5.3.2") && substr($this->GetPrefix(),0,3) == "ssl")

    6475. 

  6475.                 {

    6476. 

  6476.                     if (($f_sock = $this->_SSLOpen($s_ip,$errno,$errstr,

    6477. 

  6477.                                 $this->GetConnectionTimeout())) !== FALSE)

    6478. 

  6478.                         break;

    6479. 

  6479.                 }

    6480. 

  6480.                 elseif (($f_sock = @fsockopen($this->GetPrefix().$s_ip,$this->GetPort(),

    6481. 

  6481.                                 $errno,$errstr,$this->GetConnectionTimeout())) !== FALSE)

    6482. 

  6482.                 break;

    6483. 

  6483.             }

    6484. 

  6484.         }

    6485. 

  6485.         if ($f_sock === FALSE)

    6486. 

  6486.         {

    6487. 

  6487.             FMDebug("open failed: $errno $errstr");

    6488. 

  6488.             return ($this->_SetError($this->nErrSocket,$errno,$errstr));

    6489. 

  6489.         }

    6490. 

  6490.         $this->_fSock = $f_sock;

    6491. 

  6491.         FMDebug("Done socket open");

    6492. 

  6492.         return (TRUE);

    6493. 

  6493.     }

    6494. 

  6494. 

    6495. 

  6495.     function    Read()

    6496. 

  6496.     {

    6497. 

  6497.         $this->ClearError();

    6498. 

  6498.         $a_lines = array();

    6499. 

  6499.         while (($s_line = fgets($this->_fSock)) !== FALSE)

    6500. 

  6500.             $a_lines[] = $s_line;

    6501. 

  6501.         FMDebug("Read ".count($a_lines)." lines");

    6502. 

  6502.         return ($a_lines);

    6503. 

  6503.     }

    6504. 

  6504. 

    6505. 

  6505.     function    Write($s_str,$b_flush = TRUE)

    6506. 

  6506.     {

    6507. 

  6507.         $this->ClearError();

    6508. 

  6508.         if (!isset($this->_fSock))

    6509. 

  6509.             return ($this->_SetError($this->nErrInit));

    6510. 

  6510.         if (($n_write = fwrite($this->_fSock,$s_str)) === FALSE)

    6511. 

  6511.             return ($this->_SetError($this->nErrWrite));

    6512. 

  6512.         if ($n_write != strlen($s_str))

    6513. 

  6513.             return ($this->_SetError($this->nErrWriteShort));

    6514. 

  6514.         if ($b_flush)

    6515. 

  6515.             if (fflush($this->_fSock) === FALSE)

    6516. 

  6516.                 return ($this->_SetError($this->nErrWriteShort));

    6517. 

  6517.         return (TRUE);

    6518. 

  6518.     }

    6519. 

  6519. 

    6520. 

  6520.     function    Close()

    6521. 

  6521.     {

    6522. 

  6522.         if (isset($this->_fSock))

    6523. 

  6523.         {

    6524. 

  6524.             fclose($this->_fSock);

    6525. 

  6525.             unset($this->_fSock);

    6526. 

  6526.         }

    6527. 

  6527.     }

    6528. 

  6528. };

    6529. 

  6529. 

    6530. 

  6530. /*

    6531. 

  6531.  * Class:       HTTPGet

    6532. 

  6532.  * Description:     

    6533. 

  6533.  *  A class that implements HTTP GET method.

    6534. 

  6534.  */

    6535. 

  6535. class   HTTPGet extends NetIO

    6536. 

  6536. {

    6537. 

  6537.     var     $_sURL;

    6538. 

  6538.     var     $_aURLSplit;

    6539. 

  6539. 

    6540. 

  6540.     var     $_sRequest;

    6541. 

  6541.     var     $_aResponse;

    6542. 

  6542.     var     $_aRespHeaders;

    6543. 

  6543. 

    6544. 

  6544.     var     $_sAuthLine;

    6545. 

  6545.     var     $_sAuthType;

    6546. 

  6546.     var     $_sAuthUser;

    6547. 

  6547.     var     $_sAuthPass;

    6548. 

  6548. 

    6549. 

  6549.     var     $_sAgent;

    6550. 

  6550. 

    6551. 

  6551.     var     $nErrParse =    -1000;      // failed to parse URL

    6552. 

  6552.     var     $nErrScheme =   -1001;      // unsupported URL scheme

    6553. 

  6553. 

    6554. 

  6554.     function    HTTPGet($s_url = "")

    6555. 

  6555.     {

    6556. 

  6556.         NetIO::NetIO();

    6557. 

  6557.         $this->_aURLSplit = array();

    6558. 

  6558.         if (($this->_sURL = $s_url) !== "")

    6559. 

  6559.             $this->_SplitURL();

    6560. 

  6560.     }

    6561. 

  6561. 

    6562. 

  6562.     function    _SplitURL()

    6563. 

  6563.     {

    6564. 

  6564.         FMDebug("URL: ".$this->_sURL);

    6565. 

  6565.         if (($this->_aURLSplit = parse_url($this->_sURL)) === FALSE)

    6566. 

  6566.         {

    6567. 

  6567.             $this->_aURLSplit = array();

    6568. 

  6568.             return ($this->_SetError($this->nErrParse));

    6569. 

  6569.         }

    6570. 

  6570.         return (TRUE);

    6571. 

  6571.     }

    6572. 

  6572. 

    6573. 

  6573.     function    GetURLSplit()

    6574. 

  6574.     {

    6575. 

  6575.         return ($this->_aURLSplit);

    6576. 

  6576.     }

    6577. 

  6577. 

    6578. 

  6578.     function    SetURL($s_url)

    6579. 

  6579.     {

    6580. 

  6580.         $this->_aURLSplit = array();

    6581. 

  6581.         $this->_sURL = $s_url;

    6582. 

  6582.         return ($this->_SplitURL());

    6583. 

  6583.     }

    6584. 

  6584. 

    6585. 

  6585.     function    _Init()

    6586. 

  6586.     {

    6587. 

  6587.         if (!isset($this->_aURLSplit["host"]))

    6588. 

  6588.             return ($this->_SetError($this->nErrInit));

    6589. 

  6589.         $this->SetHost($this->_aURLSplit["host"]);

    6590. 

  6590.         $i_port = 80;

    6591. 

  6591.         if (isset($this->_aURLSplit["scheme"]))

    6592. 

  6592.         {

    6593. 

  6593.             switch (strtolower($this->_aURLSplit["scheme"]))

    6594. 

  6594.             {

    6595. 

  6595.             case "http":

    6596. 

  6596.                     break;

    6597. 

  6597.             case "https":

    6598. 

  6598.                 $i_port = 443;

    6599. 

  6599.                 break;

    6600. 

  6600.             default:

    6601. 

  6601.                 return ($this->_SetError($this->nErrScheme));

    6602. 

  6602.             }

    6603. 

  6603.         }

    6604. 

  6604.         if (isset($this->_aURLSplit["port"]))

    6605. 

  6605.             $i_port = $this->_aURLSplit["port"];

    6606. 

  6606.         if ($i_port == 443)

    6607. 

  6607.                 //

    6608. 

  6608.                 // we require ssl:// for port 443

    6609. 

  6609.                 //

    6610. 

  6610.             $this->SetPrefix("ssl://");

    6611. 

  6611.         $this->SetPort($i_port);

    6612. 

  6612.         return (TRUE);

    6613. 

  6613.     }

    6614. 

  6614. 

    6615. 

  6615.     function    _SendRequest()

    6616. 

  6616.     {

    6617. 

  6617.         FMDebug("Path: ".$this->_aURLSplit["path"]);

    6618. 

  6618.         if (!isset($this->_aURLSplit["path"]) || $this->_aURLSplit["path"] === "")

    6619. 

  6619.             $s_path = "/";          // default path

    6620. 

  6620.         else

    6621. 

  6621.             $s_path = $this->_aURLSplit["path"];

    6622. 

  6622.         if (isset($this->_aURLSplit["query"]))

    6623. 

  6623.         {

    6624. 

  6624.                 //

    6625. 

  6625.                 // add the query to the path

    6626. 

  6626.                 // Note that parse_url decodes the query string (urldecode), so

    6627. 

  6627.                 // we need to split it into its component parameters

    6628. 

  6628.                 // are re-encode their values.  Calling urlencode($this->_aURLSplit["query"])

    6629. 

  6629.                 // encodes the '=' between parameters and this breaks things.

    6630. 

  6630.                 //

    6631. 

  6631.             $a_params = explode('&',$this->_aURLSplit["query"]);

    6632. 

  6632.             foreach ($a_params as $i_idx=>$s_param)

    6633. 

  6633.             {

    6634. 

  6634.                 if (($i_pos = strpos($s_param,"=")) === false)

    6635. 

  6635.                     $a_params[$i_idx] = urlencode($s_param);

    6636. 

  6636.                 else

    6637. 

  6637.                     $a_params[$i_idx] = substr($s_param,0,$i_pos).'='.

    6638. 

  6638.                                             urlencode(substr($s_param,$i_pos+1));

    6639. 

  6639.             }

    6640. 

  6640.             $s_path .= "?".implode('&',$a_params);

    6641. 

  6641.         }

    6642. 

  6642.             //

    6643. 

  6643.             // add the fragment to the path.

    6644. 

  6644.             //

    6645. 

  6645.         if (isset($this->_aURLSplit["fragment"]))

    6646. 

  6646.             $s_path .= '#'.urlencode($this->_aURLSplit["fragment"]);

    6647. 

  6647.             //

    6648. 

  6648.             // build the request

    6649. 

  6649.             //

    6650. 

  6650.         $s_req = "GET $s_path HTTP/1.0\r\n";

    6651. 

  6651.                 //

    6652. 

  6652.                 // Add authentication

    6653. 

  6653.                 //

    6654. 

  6654.         if (isset($this->_sAuthLine))

    6655. 

  6655.             $s_req .= "Authorization: $this->_sAuthLine\r\n";

    6656. 

  6656.         elseif (isset($this->_sAuthType))

    6657. 

  6657.             $s_req .= "Authorization: ".$this->_sAuthType." ".

    6658. 

  6658.                         base64_encode($this->_sAuthUser.":".$this->_sAuthPass)."\r\n";

    6659. 

  6659.             //

    6660. 

  6660.             // Specify the host name

    6661. 

  6661.             //

    6662. 

  6662.         $s_req .= "Host: ".$this->GetHost()."\r\n";

    6663. 

  6663.             //

    6664. 

  6664.             // Specify the user agent

    6665. 

  6665.             //

    6666. 

  6666.         if (isset($this->_sAgent))

    6667. 

  6667.             $s_req .= "User-Agent: ".$this->_sAgent."\r\n";

    6668. 

  6668.             //

    6669. 

  6669.             // Accept any output

    6670. 

  6670.             //

    6671. 

  6671.         $s_req .= "Accept: */*\r\n";

    6672. 

  6672.             //

    6673. 

  6673.             // End of request headers

    6674. 

  6674.             //

    6675. 

  6675.         $s_req .= "\r\n";

    6676. 

  6676.         $this->_sRequest = $s_req;

    6677. 

  6677.         return (parent::Write($s_req));

    6678. 

  6678.     }

    6679. 

  6679. 

    6680. 

  6680.     function    _GetResponse()

    6681. 

  6681.     {

    6682. 

  6682.         FMDebug("Reading");

    6683. 

  6683.         if (($a_lines = parent::Read()) === FALSE)

    6684. 

  6684.             return (FALSE);

    6685. 

  6685. 

    6686. 

  6686.         $this->_aRespHeaders = $this->_aResponse = array();

    6687. 

  6687.         $b_body = FALSE;

    6688. 

  6688.         for ($ii = 0 ; $ii < count($a_lines) ; $ii++)

    6689. 

  6689.         {

    6690. 

  6690.             if ($b_body)

    6691. 

  6691.             {

    6692. 

  6692.                 //FMDebug("Body line: ".rtrim($a_lines[$ii]));

    6693. 

  6693.                 $this->_aResponse[] = $a_lines[$ii];

    6694. 

  6694.             }

    6695. 

  6695.             elseif ($a_lines[$ii] == "\r\n" || $a_lines[$ii] == "\n")

    6696. 

  6696.                 $b_body = TRUE;

    6697. 

  6697.             else

    6698. 

  6698.             {

    6699. 

  6699.                 //FMDebug("Header line: ".rtrim($a_lines[$ii]));

    6700. 

  6700.                 $this->_aRespHeaders[] = $a_lines[$ii];

    6701. 

  6701.             }

    6702. 

  6702.         }

    6703. 

  6703.         return (TRUE);

    6704. 

  6704.     }

    6705. 

  6705. 

    6706. 

  6706.     function    GetResponseHeaders()

    6707. 

  6707.     {

    6708. 

  6708.         return ($this->_aRespHeaders);

    6709. 

  6709.     }

    6710. 

  6710. 

    6711. 

  6711.     function    FindHeader($s_name)

    6712. 

  6712.     {

    6713. 

  6713.         $s_name = strtolower($s_name);

    6714. 

  6714.         $i_len = strlen($s_name);

    6715. 

  6715.         for ($ii = 0 ; $ii < count($this->_aRespHeaders) ; $ii++)

    6716. 

  6716.         {

    6717. 

  6717.             $s_line = $this->_aRespHeaders[$ii];

    6718. 

  6718.             if (($s_hdr = substr($s_line,0,$i_len)) !== false)

    6719. 

  6719.             {

    6720. 

  6720.                 $s_hdr = strtolower($s_hdr);

    6721. 

  6721.                 if ($s_hdr === $s_name && substr($s_line,$i_len,1) === ":")

    6722. 

  6722.                     return (trim(substr($s_line,$i_len+1)));

    6723. 

  6723.             }

    6724. 

  6724.         }

    6725. 

  6725.         return (false);

    6726. 

  6726.     }

    6727. 

  6727. 

    6728. 

  6728.     function    GetHTTPStatus()

    6729. 

  6729.     {

    6730. 

  6730.         $i_http_code = 0;

    6731. 

  6731.         $s_status = "";

    6732. 

  6732.         for ($ii = 0 ; $ii < count($this->_aRespHeaders) ; $ii++)

    6733. 

  6733.         {

    6734. 

  6734.             $s_line = $this->_aRespHeaders[$ii];

    6735. 

  6735.             if (substr($s_line,0,4) == "HTTP")

    6736. 

  6736.             {

    6737. 

  6737.                 $i_pos = strpos($s_line," ");

    6738. 

  6738.                 $s_status = substr($s_line,$i_pos+1);

    6739. 

  6739.                 $i_end_pos = strpos($s_status," ");

    6740. 

  6740.                 if ($i_end_pos === false)

    6741. 

  6741.                     $i_end_pos = strlen($s_status);

    6742. 

  6742.                 $i_http_code = (int) substr($s_status,0,$i_end_pos);

    6743. 

  6743.             }

    6744. 

  6744.         }

    6745. 

  6745.         return (array($i_http_code,$s_status));

    6746. 

  6746.     }

    6747. 

  6747. 

    6748. 

  6748.     function    Resolve()

    6749. 

  6749.     {

    6750. 

  6750.         if (!$this->_Init())

    6751. 

  6751.             return (FALSE);

    6752. 

  6752.         return (parent::Resolve());

    6753. 

  6753.     }

    6754. 

  6754. 

    6755. 

  6755.     function    Read()

    6756. 

  6756.     {

    6757. 

  6757.         if (!$this->_Init())

    6758. 

  6758.             return (FALSE);

    6759. 

  6759.         FMDebug("Init done");

    6760. 

  6760.         if (!$this->Open())

    6761. 

  6761.             return (FALSE);

    6762. 

  6762.         FMDebug("Open done");

    6763. 

  6763.         if (!$this->_SendRequest())

    6764. 

  6764.             return (FALSE);

    6765. 

  6765.         FMDebug("Send done");

    6766. 

  6766.         if (!$this->_GetResponse())

    6767. 

  6767.             return (FALSE);

    6768. 

  6768.         FMDebug("Get done");

    6769. 

  6769.         $this->Close();

    6770. 

  6770.         return ($this->_aResponse);

    6771. 

  6771.     }

    6772. 

  6772. 

    6773. 

  6773.     function    SetAuthenticationLine($s_auth)

    6774. 

  6774.     {

    6775. 

  6775.         $this->_sAuthLine = $s_auth;

    6776. 

  6776.     }

    6777. 

  6777. 

    6778. 

  6778.     function    SetAuthentication($s_type,$s_user,$s_pass)

    6779. 

  6779.     {

    6780. 

  6780.         $this->_sAuthType = $s_type;

    6781. 

  6781.         $this->_sAuthUser = $s_user;

    6782. 

  6782.         $this->_sAuthPass = $s_pass;

    6783. 

  6783.     }

    6784. 

  6784. 

    6785. 

  6785.     function    SetAgent($s_agent)

    6786. 

  6786.     {

    6787. 

  6787.         $this->_sAgent = $s_agent;

    6788. 

  6788.     }

    6789. 

  6789. };

    6790. 

  6790. 

    6791. 

  6791.     //

    6792. 

  6792.     // Load a template file into a string.

    6793. 

  6793. 

    6794. 

  6794.     //

    6795. 

  6795. function LoadTemplate($s_name,$s_dir,$s_url,$b_ret_lines = false)

    6796. 

  6796. {

    6797. 

  6797.     global  $php_errormsg;

    6798. 

  6798. 

    6799. 

  6799.     $s_buf = "";

    6800. 

  6800.     $a_lines = array();

    6801. 

  6801.     if (!empty($s_dir))

    6802. 

  6802.     {

    6803. 

  6803.         $s_name = "$s_dir/".basename($s_name);

    6804. 

  6804. @       $fp = fopen($s_name,"r");

    6805. 

  6805.         if ($fp === false)

    6806. 

  6806.         {

    6807. 

  6807.             SendAlert(GetMessage(MSG_OPEN_TEMPLATE,array("NAME"=>$s_name,

    6808. 

  6808.                                                     "ERROR"=>CheckString($php_errormsg))));

    6809. 

  6809.             return (false);

    6810. 

  6810.         }

    6811. 

  6811.         if ($b_ret_lines)

    6812. 

  6812.             $a_lines = ReadLines($fp);

    6813. 

  6813.         else

    6814. 

  6814.                 //

    6815. 

  6815.                 // load the whole template into a string

    6816. 

  6816.                 //

    6817. 

  6817.             $s_buf = fread($fp,filesize($s_name));

    6818. 

  6818.         fclose($fp);

    6819. 

  6819.     }

    6820. 

  6820.     else

    6821. 

  6821.     {

    6822. 

  6822.         if (substr($s_url,-1) == '/')

    6823. 

  6823.             $s_name = "$s_url".basename($s_name);

    6824. 

  6824.         else

    6825. 

  6825.             $s_name = "$s_url/".basename($s_name);

    6826. 

  6826.         if (($m_data = GetURL($s_name,$s_error,$b_ret_lines)) === false)

    6827. 

  6827.         {

    6828. 

  6828.             SendAlert($s_error);

    6829. 

  6829.             return (false);

    6830. 

  6830.         }

    6831. 

  6831.         if ($b_ret_lines)

    6832. 

  6832.         {

    6833. 

  6833.             $a_lines = $m_data;

    6834. 

  6834.                 //

    6835. 

  6835.                 // strip line terminations from each line

    6836. 

  6836.                 //

    6837. 

  6837.             for ($ii = count($a_lines) ; --$ii >= 0 ; )

    6838. 

  6838.             {

    6839. 

  6839.                 $s_line = $a_lines[$ii];

    6840. 

  6840.                 $s_line = str_replace("\r","",$s_line);

    6841. 

  6841.                 $s_line = str_replace("\n","",$s_line);

    6842. 

  6842.                 $a_lines[$ii] = $s_line;

    6843. 

  6843.             }

    6844. 

  6844.         }

    6845. 

  6845.         else

    6846. 

  6846.             $s_buf = $m_data;

    6847. 

  6847. 

    6848. 

  6848.     }

    6849. 

  6849.     return ($b_ret_lines ? $a_lines : $s_buf);

    6850. 

  6850. }

    6851. 

  6851. 

    6852. 

  6852.     //

    6853. 

  6853.     // To show an error template.  The template must be HTML and, for security

    6854. 

  6854.     // reasons, must be a file on the server in the directory specified

    6855. 

  6855.     // by $TEMPLATEDIR or $TEMPLATEURL.

    6856. 

  6856.     // $a_specs is an array of substitutions to perform, as follows:

    6857. 

  6857.     //      tag-name    replacement string

    6858. 

  6858.     //

    6859. 

  6859.     // For example:

    6860. 

  6860.     //      "fmerror"=>"An error message"

    6861. 

  6861.     //

    6862. 

  6862. function ShowErrorTemplate($s_name,$a_specs,$b_user_error)

    6863. 

  6863. {

    6864. 

  6864.     global  $TEMPLATEURL,$TEMPLATEDIR;

    6865. 

  6865. 

    6866. 

  6866.     if (empty($TEMPLATEDIR) && empty($TEMPLATEURL))

    6867. 

  6867.     {

    6868. 

  6868.         SendAlert(GetMessage(MSG_TEMPLATES));

    6869. 

  6869.         return (false);

    6870. 

  6870.     }

    6871. 

  6871.     if (($s_buf = LoadTemplate($s_name,$TEMPLATEDIR,$TEMPLATEURL)) === false)

    6872. 

  6872.         return (false);

    6873. 

  6873. 

    6874. 

  6874.         //

    6875. 

  6875.         // now look for the tags to replace

    6876. 

  6876.         //

    6877. 

  6877.     foreach ($a_specs as $s_tag=>$s_value)

    6878. 

  6878.             //

    6879. 

  6879.             // search for

    6880. 

  6880.             //      <tagname/>

    6881. 

  6881.             // or

    6882. 

  6882.             //      [tagname/]

    6883. 

  6883.             // with optional whitespace

    6884. 

  6884.             //

    6885. 

  6885.         $s_buf = preg_replace('/[<\[]\s*'.preg_quote($s_tag,"/").'\s*\/\s*[>\]]/ims',

    6886. 

  6886.                             nl2br($s_value),$s_buf);

    6887. 

  6887.     if ($b_user_error)

    6888. 

  6888.     {

    6889. 

  6889.             // strip any <fmusererror> and </fmusererror> tags

    6890. 

  6890.                 // or [fmusererrors] and [/fmusererror] tags

    6891. 

  6891.             //

    6892. 

  6892.             // You can show information that's specific to user

    6893. 

  6893.             // errors between these special tags.

    6894. 

  6894.             //

    6895. 

  6895.         $s_buf = preg_replace('/[<\[]\s*\/?\s*fmusererror\s*[>\]]/ims','',$s_buf);

    6896. 

  6896.             //

    6897. 

  6897.             // since this isn't a system error, strip anything between

    6898. 

  6898.             // <fmsyserror> and </fmsyserror>

    6899. 

  6899.             // or [fmsyserrors] and [/fmsyserror] tags

    6900. 

  6900.             //

    6901. 

  6901.         $s_buf = preg_replace('/[<\[]\s*fmsyserror\s*[>\]].*[<\[]\s*\/\s*fmsyserror\s*[>\]]/ims','',$s_buf);

    6902. 

  6902.     }

    6903. 

  6903.     else

    6904. 

  6904.     {

    6905. 

  6905.             // strip any <fmsyserror> and </fmsyserror> tags

    6906. 

  6906.             // or [fmsyserrors] and [/fmsyserror] tags

    6907. 

  6907.             //

    6908. 

  6908.             // You can show information that's specific to system

    6909. 

  6909.             // errors between these special tags.

    6910. 

  6910.             //

    6911. 

  6911.         $s_buf = preg_replace('/[<\[]\s*\/?\s*fmsyserror\s*[>\]]/ims','',$s_buf);

    6912. 

  6912.             //

    6913. 

  6913.             // since this isn't a user error, strip anything between

    6914. 

  6914.             // <fmusererror> and </fmusererror>

    6915. 

  6915.             // or [fmusererrors] and [/fmusererror] tags

    6916. 

  6916.             //

    6917. 

  6917.         $s_buf = preg_replace('/[<\[]\s*fmusererror\s*[>\]].*[<\[]\s*\/\s*fmusererror\s*[>\]]/ims','',$s_buf);

    6918. 

  6918.     }

    6919. 

  6919.         //

    6920. 

  6920.         // just output the page

    6921. 

  6921.         //

    6922. 

  6922.     echo $s_buf;

    6923. 

  6923.     return (true);

    6924. 

  6924. }

    6925. 

  6925. 

    6926. 

  6926.     //

    6927. 

  6927.     // To show an error to the user.

    6928. 

  6928.     //

    6929. 

  6929. function ShowError($error_code,$error_mesg,$b_user_error,

    6930. 

  6930.                 $b_alerted = false,$a_item_list = array(),$s_extra_info = "")

    6931. 

  6931. {

    6932. 

  6932.     global  $SPECIAL_FIELDS,$SPECIAL_MULTI,$SPECIAL_VALUES;

    6933. 

  6933.     global  $aServerVars,$aStrippedFormVars;

    6934. 

  6934. 

    6935. 

  6935.         //

    6936. 

  6936.         // Testing with PHP 4.0.6 indicates that sessions don't always work.

    6937. 

  6937.         // So, we'll also add the error to the URL, unless

    6938. 

  6938.         // PUT_DATA_IN_URL is false.

    6939. 

  6939.         //

    6940. 

  6940.     SetSession("FormError",$error_mesg);

    6941. 

  6941.     SetSession("FormErrorInfo",$s_extra_info);

    6942. 

  6942.     SetSession("FormErrorCode",$error_code);

    6943. 

  6943.     SetSession("FormErrorItems",$a_item_list);

    6944. 

  6944.     SetSession("FormIsUserError",$b_user_error);

    6945. 

  6945.     SetSession("FormAlerted",$b_alerted);

    6946. 

  6946.     SetSession("FormData",array());

    6947. 

  6947. 

    6948. 

  6948.     $bad_url = $SPECIAL_VALUES["bad_url"];

    6949. 

  6949.     $bad_template = $SPECIAL_VALUES["bad_template"];

    6950. 

  6950.     $this_form = $SPECIAL_VALUES["this_form"];

    6951. 

  6951.     if (IsAjax())

    6952. 

  6952.     {

    6953. 

  6953.         JSON_Result("ERROR",array("ErrorCode"=>$error_code,

    6954. 

  6954.                 "UserError"=>$b_user_error,

    6955. 

  6955.                 "ErrorMesg"=>$error_mesg,

    6956. 

  6956.                 "Alerted"=>$b_alerted,

    6957. 

  6957.                 "ErrorItems"=>$a_item_list));

    6958. 

  6958.         ZapSession();

    6959. 

  6959.     }

    6960. 

  6960.     elseif (!empty($bad_url))

    6961. 

  6961.     {

    6962. 

  6962.         $a_params = array();

    6963. 

  6963.         if (PUT_DATA_IN_URL)

    6964. 

  6964.         {

    6965. 

  6965.             $a_params[] = "this_form=".urlencode("$this_form");

    6966. 

  6966.             $a_params[] = "bad_template=".urlencode("$bad_template");

    6967. 

  6967.             $a_params[] = "error=".urlencode("$error_mesg");

    6968. 

  6968.             $a_params[] = "extra=".urlencode("$s_extra_info");

    6969. 

  6969.             $a_params[] = "errcode=".urlencode("$error_code");

    6970. 

  6970.             $a_params[] = "isusererror=".($b_user_error ? "1" : "0");

    6971. 

  6971.             $a_params[] = "alerted=".($b_alerted ? "1" : "0");

    6972. 

  6972.             $i_count = 1;

    6973. 

  6973.             foreach ($a_item_list as $s_item)

    6974. 

  6974.             {

    6975. 

  6975.                 $a_params[] = "erroritem$i_count=".urlencode("$s_item");

    6976. 

  6976.                 $i_count++;

    6977. 

  6977.             }

    6978. 

  6978.         }

    6979. 

  6979.         else

    6980. 

  6980.         {

    6981. 

  6981.             $a_sess_data = GetSession("FormData");

    6982. 

  6982.             $a_sess_data["this_form"] = "$this_form";

    6983. 

  6983.             $a_sess_data["bad_template"] = "$bad_template";

    6984. 

  6984.             SetSession("FormData",$a_sess_data);

    6985. 

  6985.                 //

    6986. 

  6986.                 // tell the bad_url to look in the session only

    6987. 

  6987.                 //

    6988. 

  6988.             $a_params[] = "insession=1";

    6989. 

  6989.         }

    6990. 

  6990.             //

    6991. 

  6991.             // Add the posted data to the URL so that an intelligent

    6992. 

  6992.             // $bad_url can call the form again

    6993. 

  6993.             //

    6994. 

  6994.         foreach ($aStrippedFormVars as $s_name=>$m_value)

    6995. 

  6995.         {

    6996. 

  6996.                 //

    6997. 

  6997.                 // skip special fields

    6998. 

  6998.                 //

    6999. 

  6999.             $b_special = false;

    7000. 

  7000.             if (in_array($s_name,$SPECIAL_FIELDS))

    7001. 

  7001.                 $b_special = true;

    7002. 

  7002.             else

    7003. 

  7003.             {

    7004. 

  7004.                 foreach ($SPECIAL_MULTI as $s_multi_fld)

    7005. 

  7005.                 {

    7006. 

  7006.                     $i_len = strlen($s_multi_fld);

    7007. 

  7007.                     if (substr($s_name,0,$i_len) == $s_multi_fld)

    7008. 

  7008.                     {

    7009. 

  7009.                         $i_index = (int) substr($s_name,$i_len);

    7010. 

  7010.                         if ($i_index > 0)

    7011. 

  7011.                         {

    7012. 

  7012.                             $b_special = true;

    7013. 

  7013.                             break;

    7014. 

  7014.                         }

    7015. 

  7015.                     }

    7016. 

  7016.                 }

    7017. 

  7017.             }

    7018. 

  7018.             if (!$b_special)

    7019. 

  7019.             {

    7020. 

  7020.                 if (PUT_DATA_IN_URL)

    7021. 

  7021.                 {

    7022. 

  7022.                     if (is_array($m_value))

    7023. 

  7023.                         foreach ($m_value as $s_value)

    7024. 

  7024.                             $a_params[] = "$s_name".'[]='.

    7025. 

  7025.                                         urlencode(substr($s_value,0,MAXSTRING));

    7026. 

  7026.                     else

    7027. 

  7027.                         $a_params[] = "$s_name=".urlencode(substr($m_value,0,MAXSTRING));

    7028. 

  7028.                 }

    7029. 

  7029.                 else

    7030. 

  7030.                 {

    7031. 

  7031.                     $a_sess_data = GetSession("FormData");

    7032. 

  7032.                     if (is_array($m_value))

    7033. 

  7033.                         $a_sess_data["$s_name"] = $m_value;

    7034. 

  7034.                     else

    7035. 

  7035.                         $a_sess_data["$s_name"] = substr($m_value,0,MAXSTRING);

    7036. 

  7036.                     SetSession("FormData",$a_sess_data);

    7037. 

  7037.                 }

    7038. 

  7038.             }

    7039. 

  7039.         }

    7040. 

  7040.             //

    7041. 

  7041.             // Now add the authentication data, if any

    7042. 

  7042.             //

    7043. 

  7043.         if ((isset($aServerVars["PHP_AUTH_USER"]) &&

    7044. 

  7044.                 $aServerVars["PHP_AUTH_USER"] !== "") ||

    7045. 

  7045.             (isset($aServerVars["PHP_AUTH_PW"]) &&

    7046. 

  7046.                 $aServerVars["PHP_AUTH_PW"] !== ""))

    7047. 

  7047.         {

    7048. 

  7048.             if (PUT_DATA_IN_URL)

    7049. 

  7049.             {

    7050. 

  7050.                 if (isset($aServerVars["PHP_AUTH_USER"]))

    7051. 

  7051.                     $a_params[] = "PHP_AUTH_USER=".urlencode($aServerVars["PHP_AUTH_USER"]);

    7052. 

  7052. 

    7053. 

  7053.                 if (isset($aServerVars["PHP_AUTH_PW"]))

    7054. 

  7054.                     $a_params[] = "PHP_AUTH_PW=".urlencode($aServerVars["PHP_AUTH_PW"]);

    7055. 

  7055. 

    7056. 

  7056.                 if (isset($aServerVars["PHP_AUTH_TYPE"]))

    7057. 

  7057.                     $a_params[] = "PHP_AUTH_TYPE=".urlencode($aServerVars["PHP_AUTH_TYPE"]);

    7058. 

  7058.             }

    7059. 

  7059.             else

    7060. 

  7060.             {

    7061. 

  7061.                 $a_sess_data = GetSession("FormData");

    7062. 

  7062.                 if (isset($aServerVars["PHP_AUTH_USER"]))

    7063. 

  7063.                     $a_sess_data["PHP_AUTH_USER"] = $aServerVars["PHP_AUTH_USER"];

    7064. 

  7064. 

    7065. 

  7065.                 if (isset($aServerVars["PHP_AUTH_PW"]))

    7066. 

  7066.                     $a_sess_data["PHP_AUTH_PW"] = $aServerVars["PHP_AUTH_PW"];

    7067. 

  7067. 

    7068. 

  7068.                 if (isset($aServerVars["PHP_AUTH_TYPE"]))

    7069. 

  7069.                     $a_sess_data["PHP_AUTH_TYPE"] = $aServerVars["PHP_AUTH_TYPE"];

    7070. 

  7070.                 SetSession("FormData",$a_sess_data);

    7071. 

  7071.             }

    7072. 

  7072.         }

    7073. 

  7073.         $bad_url = AddURLParams($bad_url,$a_params,false);

    7074. 

  7074.         Redirect($bad_url,GetMessage(MSG_FORM_ERROR));

    7075. 

  7075.     }

    7076. 

  7076.     else

    7077. 

  7077.     {

    7078. 

  7078.         if (!empty($bad_template))

    7079. 

  7079.         {

    7080. 

  7080.             $a_specs = array("fmerror"=>htmlspecialchars("$error_mesg"),

    7081. 

  7081.                             "fmerrorcode"=>htmlspecialchars("$error_code"),

    7082. 

  7082.                             "fmfullerror"=>htmlspecialchars("$error_mesg")."\n".

    7083. 

  7083.                                             htmlspecialchars("$s_extra_info"),

    7084. 

  7084.                             "fmerrorextra"=>htmlspecialchars("$s_extra_info"),);

    7085. 

  7085.             for ($i_count = 1 ; $i_count <= 20 ; $i_count++)

    7086. 

  7086.                 $a_specs["fmerroritem$i_count"] = "";

    7087. 

  7087.             $i_count = 1;

    7088. 

  7088.             foreach ($a_item_list as $s_item)

    7089. 

  7089.             {

    7090. 

  7090.                 $a_specs["fmerroritem$i_count"] = htmlspecialchars($s_item);

    7091. 

  7091.                 $i_count++;

    7092. 

  7092.             }

    7093. 

  7093.             $s_list = "";

    7094. 

  7094.             foreach ($a_item_list as $s_item)

    7095. 

  7095.                 $s_list .= "<li>".htmlspecialchars($s_item)."</li>";

    7096. 

  7096.             $a_specs["fmerroritemlist"] = $s_list;

    7097. 

  7097.             if (ShowErrorTemplate($bad_template,$a_specs,$b_user_error))

    7098. 

  7098.                 return;

    7099. 

  7099.         }

    7100. 

  7100.         $s_text = GetMessage(MSG_ERROR_PROC);

    7101. 

  7101.         if ($b_user_error)

    7102. 

  7102.             $s_text .= $error_mesg."\n".FixedHTMLEntities($s_extra_info);

    7103. 

  7103.         else

    7104. 

  7104.         {

    7105. 

  7105.             global  $SERVER;

    7106. 

  7106. 

    7107. 

  7107.             if ($b_alerted)

    7108. 

  7108.                 $s_text .= GetMessage(MSG_ALERT_DONE,array("SERVER"=>$SERVER));

    7109. 

  7109.             else

    7110. 

  7110.                 $s_text .= GetMessage(MSG_PLS_CONTACT,array("SERVER"=>$SERVER));

    7111. 

  7111.             $s_text .= GetMessage(MSG_APOLOGY,array("SERVER"=>$SERVER));

    7112. 

  7112.         }

    7113. 

  7113.         CreatePage($s_text,GetMessage(MSG_FORM_ERROR),false);

    7114. 

  7114.             //

    7115. 

  7115.             // the session data is not needed now

    7116. 

  7116.             //

    7117. 

  7117.         ZapSession();

    7118. 

  7118.     }

    7119. 

  7119. }

    7120. 

  7120. 

    7121. 

  7121.     //

    7122. 

  7122.     // Report an error.  Same as Error, but implements

    7123. 

  7123.     // ATTACK_DETECTION_IGNORE_ERRORS.

    7124. 

  7124.     //

    7125. 

  7125. function ErrorWithIgnore($error_code,$error_mesg,$b_filter = true,$show = true,$int_mesg = "")

    7126. 

  7126. {

    7127. 

  7127.     if (function_exists('FMHookErrorWithIgnore'))

    7128. 

  7128. 

    7129. 

  7129.         FMHookErrorWithIgnore($error_code,$error_mesg,$b_filter,$show,$int_mesg);

    7130. 

  7130. 

    7131. 

  7131.     $b_alerted = false;

    7132. 

  7132.     if (!ATTACK_DETECTION_IGNORE_ERRORS)

    7133. 

  7133.         if (SendAlert("$error_code\n *****$int_mesg*****\nError=$error_mesg\n",$b_filter))

    7134. 

  7134.             $b_alerted = true;

    7135. 

  7135.     if ($show)

    7136. 

  7136.         ShowError($error_code,$error_mesg,false,$b_alerted);

    7137. 

  7137.     else

    7138. 

  7138.             //

    7139. 

  7139.             // show something to the user

    7140. 

  7140.             //

    7141. 

  7141.         ShowError($error_code,GetMessage(MSG_SUBM_FAILED),false,$b_alerted);

    7142. 

  7142.     exit;

    7143. 

  7143. }

    7144. 

  7144. 

    7145. 

  7145.     //

    7146. 

  7146.     // Report an error

    7147. 

  7147.     //

    7148. 

  7148. function Error($error_code,$error_mesg,$b_filter = true,$show = true,$int_mesg = "")

    7149. 

  7149. {

    7150. 

  7150.     if (function_exists('FMHookError'))

    7151. 

  7151.         FMHookError($error_code,$error_mesg,$b_filter,$show,$int_mesg);

    7152. 

  7152. 

    7153. 

  7153.     $b_alerted = false;

    7154. 

  7154.     if (SendAlert("$error_code\n *****$int_mesg*****\nError=$error_mesg\n",$b_filter))

    7155. 

  7155.         $b_alerted = true;

    7156. 

  7156.     if ($show)

    7157. 

  7157.         ShowError($error_code,$error_mesg,false,$b_alerted);

    7158. 

  7158.     else

    7159. 

  7159.             //

    7160. 

  7160.             // show something to the user

    7161. 

  7161.             //

    7162. 

  7162.         ShowError($error_code,GetMessage(MSG_SUBM_FAILED),false,$b_alerted);

    7163. 

  7163.     exit;

    7164. 

  7164. }

    7165. 

  7165. 

    7166. 

  7166.     //

    7167. 

  7167.     // Report a user error

    7168. 

  7168.     //

    7169. 

  7169. function UserError($s_error_code,$s_error_mesg,

    7170. 

  7170.                     $s_extra_info = "",$a_item_list = array())

    7171. 

  7171. {

    7172. 

  7172.     if (function_exists('FMHookUserError'))

    7173. 

  7173.         FMHookUserError($s_error_code,$s_error_mesg,$s_extra_info,$a_item_list);

    7174. 

  7174.     $b_alerted = false;

    7175. 

  7175.     if (ALERT_ON_USER_ERROR &&

    7176. 

  7176.             SendAlert("$s_error_code\nError=$s_error_mesg\n$s_extra_info\n"))

    7177. 

  7177.         $b_alerted = true;

    7178. 

  7178.     ShowError($s_error_code,$s_error_mesg,true,$b_alerted,$a_item_list,$s_extra_info);

    7179. 

  7179.     exit;

    7180. 

  7180. }

    7181. 

  7181. 

    7182. 

  7182.     //

    7183. 

  7183.     // Create a simple page with the given text.

    7184. 

  7184.     //

    7185. 

  7185. function CreatePage($text,$title = "",$b_show_about = true)

    7186. 

  7186. {

    7187. 

  7187.     global  $FM_VERS,$sHTMLCharSet;

    7188. 

  7188. 

    7189. 

  7189.     if (IsAjax())

    7190. 

  7190.     {

    7191. 

  7191.         //

    7192. 

  7192.         // CreatePage should not be called in Ajax mode.

    7193. 

  7193.         // If it is, it must be an error or debugging state.

    7194. 

  7194.         //

    7195. 

  7195.         JSON_Result("ERROR",array("ErrorCode"=>$title,

    7196. 

  7196.                     "ErrorMesg"=>$text));

    7197. 

  7197.     }

    7198. 

  7198.     else

    7199. 

  7199.     {

    7200. 

  7200.         echo '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'."\n";

    7201. 

  7201.         echo '<html xmlns="http://www.w3.org/1999/xhtml">'."\n";

    7202. 

  7202.         echo "<head>\n";

    7203. 

  7203.         if (isset($sHTMLCharSet) && $sHTMLCharSet !== "")

    7204. 

  7204.             echo "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=$sHTMLCharSet\" />\n";

    7205. 

  7205.         if ($title != "")

    7206. 

  7206.             echo "<title>".FixedHTMLEntities($title)."</title>\n";

    7207. 

  7207.         echo "</head>\n";

    7208. 

  7208.         echo "<body>\n";

    7209. 

  7209.         echo nl2br($text);

    7210. 

  7210.         echo "<p />";

    7211. 

  7211.         if ($b_show_about)

    7212. 

  7212.         {

    7213. 

  7213.             echo "<p><small>\n";

    7214. 

  7214.             echo GetMessage(MSG_ABOUT_FORMMAIL,array("FM_VERS"=>$FM_VERS,

    7215. 

  7215.                                                     "TECTITE"=>"www.tectite.com"));

    7216. 

  7216.             echo "</small></p>\n";

    7217. 

  7217.         }

    7218. 

  7218.         echo "</body>\n";

    7219. 

  7219.         echo "</html>\n";

    7220. 

  7220.     }

    7221. 

  7221. }

    7222. 

  7222. 

    7223. 

  7223.     //

    7224. 

  7224.     // Strip slashes if magic_quotes_gpc is set.

    7225. 

  7225.     //

    7226. 

  7226. function StripGPC($s_value)

    7227. 

  7227. {

    7228. 

  7228.     if (get_magic_quotes_gpc() != 0)

    7229. 

  7229.         $s_value = stripslashes($s_value);

    7230. 

  7230.     return ($s_value);

    7231. 

  7231. }

    7232. 

  7232. 

    7233. 

  7233.     //

    7234. 

  7234.     // return an array, stripped of slashes if magic_quotes_gpc is set

    7235. 

  7235.     //

    7236. 

  7236. function StripGPCArray($a_values)

    7237. 

  7237. {

    7238. 

  7238.     if (get_magic_quotes_gpc() != 0)

    7239. 

  7239.         foreach ($a_values as $m_key=>$m_value)

    7240. 

  7240.             if (is_array($m_value))

    7241. 

  7241.                     //

    7242. 

  7242.                     // strip arrays recursively

    7243. 

  7243.                     //

    7244. 

  7244.                 $a_values[$m_key] = StripGPCArray($m_value);

    7245. 

  7245.             else

    7246. 

  7246.                     //

    7247. 

  7247.                     // convert scalar to string and strip

    7248. 

  7248.                     //

    7249. 

  7249.                 $a_values[$m_key] = stripslashes("$m_value");

    7250. 

  7250.     return ($a_values);

    7251. 

  7251. }

    7252. 

  7252. 

    7253. 

  7253.     //

    7254. 

  7254.     // Strip a value of unwanted characters, which might be hacks.

    7255. 

  7255.     // The stripping of \r and \n is a *critical* security feature.

    7256. 

  7256.     //

    7257. 

  7257. function Strip($value)

    7258. 

  7258. {

    7259. 

  7259.         //

    7260. 

  7260.         // When working with character sets such as UTF-8, stripping

    7261. 

  7261.         // control characters is a *really bad idea* and breaks things.

    7262. 

  7262.         // From version 8.22, FormMail only strips \r and \n as these

    7263. 

  7263.         // are really the only characters that can cause header hacks

    7264. 

  7264.         // to be inserted. (Strip means replace with a single space).

    7265. 

  7265.         // We also handle multiple spaces.

    7266. 

  7266.         //

    7267. 

  7267.     $value = preg_replace('/[ \r\n]+/'," ",$value);    // zap all CRLF and multiple blanks

    7268. 

  7268.     return ($value);

    7269. 

  7269. }

    7270. 

  7270. 

    7271. 

  7271.     //

    7272. 

  7272.     // Clean a value.  This means:

    7273. 

  7273.     //  1. convert to string

    7274. 

  7274.     //  2. truncate to maximum length

    7275. 

  7275.     //  3. strip the value of unwanted or dangerous characters (hacks)

    7276. 

  7276.     //  4. trim both ends of whitespace

    7277. 

  7277.     // Each element of an array is cleaned as above.  This process occurs

    7278. 

  7278.     // recursively, so arrays of arrays work OK too (though there's no

    7279. 

  7279.     // need for that in this program).

    7280. 

  7280.     //

    7281. 

  7281.     // Non-scalar values are changed to the string "<X>" where X is the type.

    7282. 

  7282.     // In general, FormMail won't receive non-scalar non-array values, so this

    7283. 

  7283.     // is more a future-proofing measure.

    7284. 

  7284.     //

    7285. 

  7285. function CleanValue($m_value)

    7286. 

  7286. {

    7287. 

  7287.     if (is_array($m_value))

    7288. 

  7288.     {

    7289. 

  7289.         foreach ($m_value as $m_key=>$m_item)

    7290. 

  7290.             $m_value[$m_key] = CleanValue($m_item);

    7291. 

  7291.     }

    7292. 

  7292.     elseif (!is_scalar($m_value))

    7293. 

  7293.         $m_value = "<".gettype($m_value).">";

    7294. 

  7294.     else

    7295. 

  7295.     {

    7296. 

  7296.             //

    7297. 

  7297.             // convert to string and truncate

    7298. 

  7298.             //

    7299. 

  7299.         $m_value = substr("$m_value",0,MAXSTRING);

    7300. 

  7300.             //

    7301. 

  7301.             // strip unwanted chars and trim

    7302. 

  7302.             //

    7303. 

  7303.         $m_value = trim(Strip($m_value));

    7304. 

  7304.     }

    7305. 

  7305.     return ($m_value);

    7306. 

  7306. }

    7307. 

  7307. 

    7308. 

  7308.     //

    7309. 

  7309.     // Clean a special value.  Special values listed in $SPECIAL_NOSTRIP

    7310. 

  7310.     // will not be cleaned.

    7311. 

  7311.     //

    7312. 

  7312. function SpecialCleanValue($s_name,$m_value)

    7313. 

  7313. {

    7314. 

  7314.     global  $SPECIAL_NOSTRIP;

    7315. 

  7315. 

    7316. 

  7316.     if (!in_array($s_name,$SPECIAL_NOSTRIP))

    7317. 

  7317.         $m_value = CleanValue($m_value);

    7318. 

  7318.     return ($m_value);

    7319. 

  7319. }

    7320. 

  7320. 

    7321. 

  7321.     //

    7322. 

  7322.     // Return the fields and their values in a string containing one

    7323. 

  7323.     // field per line.

    7324. 

  7324.     //

    7325. 

  7325. function MakeFieldOutput($a_order,$a_fields,$s_line_feed = BODY_LF)

    7326. 

  7326. {

    7327. 

  7327.     $n_order = count($a_order);

    7328. 

  7328.     $s_output = "";

    7329. 

  7329.     for ($ii = 0 ; $ii < $n_order ; $ii++)

    7330. 

  7330.     {

    7331. 

  7331.         $s_name = $a_order[$ii];

    7332. 

  7332.         if (isset($a_fields[$s_name]))

    7333. 

  7333.             $s_output .= "$s_name: ".$a_fields[$s_name].$s_line_feed;

    7334. 

  7334.     }

    7335. 

  7335.     return ($s_output);

    7336. 

  7336. }

    7337. 

  7337. 

    7338. 

  7338.     //

    7339. 

  7339.     // Check if a field name is special. Returns true if it is.

    7340. 

  7340.     //

    7341. 

  7341. function IsSpecialField($s_name)

    7342. 

  7342. {

    7343. 

  7343.     global  $SPECIAL_FIELDS;

    7344. 

  7344. 

    7345. 

  7345.     return (in_array($s_name,$SPECIAL_FIELDS));

    7346. 

  7346. }

    7347. 

  7347. 

    7348. 

  7348.     //

    7349. 

  7349.     // Set a special field value.

    7350. 

  7350.     //

    7351. 

  7351. function SetSpecialField($s_name,$m_value)

    7352. 

  7352. {

    7353. 

  7353.     global  $SPECIAL_VALUES;

    7354. 

  7354. 

    7355. 

  7355.         //

    7356. 

  7356.         // most special values cannot be arrays; ignore them if they are

    7357. 

  7357.         //

    7358. 

  7358.     if (is_array($m_value))

    7359. 

  7359.     {

    7360. 

  7360.         global  $SPECIAL_ARRAYS;

    7361. 

  7361. 

    7362. 

  7362.         if (!in_array($s_name,$SPECIAL_ARRAYS))

    7363. 

  7363.             return;

    7364. 

  7364.     }

    7365. 

  7365.     $SPECIAL_VALUES[$s_name] = SpecialCleanValue($s_name,$m_value);

    7366. 

  7366. }

    7367. 

  7367. 

    7368. 

  7368.     //

    7369. 

  7369.     // Check if a field name is a special "multi" field.

    7370. 

  7370.     // A multi field is the name plus a sequence number.  For example,

    7371. 

  7371.     //      conditions1

    7372. 

  7372.     //      conditions2

    7373. 

  7373.     // Returns a list (array) if it is, otherwise false if not.

    7374. 

  7374.     // The list contains:

    7375. 

  7375.     //      1. the name of the special multi field

    7376. 

  7376.     //      2. the index number for multi field

    7377. 

  7377.     //

    7378. 

  7378. function IsSpecialMultiField($s_name)

    7379. 

  7379. {

    7380. 

  7380.     global  $SPECIAL_MULTI;

    7381. 

  7381. 

    7382. 

  7382.     foreach ($SPECIAL_MULTI as $s_multi_fld)

    7383. 

  7383.     {

    7384. 

  7384.         $i_len = strlen($s_multi_fld);

    7385. 

  7385.             //

    7386. 

  7386.             // look for nameN where N is a number starting from 1

    7387. 

  7387.             //

    7388. 

  7388.         if (substr($s_name,0,$i_len) == $s_multi_fld)

    7389. 

  7389.         {

    7390. 

  7390.             $i_index = (int) substr($s_name,$i_len);

    7391. 

  7391.             if ($i_index > 0)

    7392. 

  7392.             {

    7393. 

  7393.                     //

    7394. 

  7394.                     // re-index to zero

    7395. 

  7395.                     //

    7396. 

  7396.                 --$i_index;

    7397. 

  7397.                 return (array($s_multi_fld,$i_index));

    7398. 

  7398.             }

    7399. 

  7399.         }

    7400. 

  7400.     }

    7401. 

  7401.     return (false);

    7402. 

  7402. }

    7403. 

  7403. 

    7404. 

  7404.     //

    7405. 

  7405.     // Set a multi field value.

    7406. 

  7406.     //

    7407. 

  7407. function SetSpecialMultiField($s_name,$i_index,$m_value)

    7408. 

  7408. {

    7409. 

  7409.     global  $SPECIAL_VALUES;

    7410. 

  7410. 

    7411. 

  7411.         //

    7412. 

  7412.         // these special fields cannot be arrays - ignore if it is

    7413. 

  7413.         //

    7414. 

  7414.     if (!is_array($m_value))

    7415. 

  7415.         $SPECIAL_VALUES[$s_name][$i_index] = SpecialCleanValue($s_name,$m_value);

    7416. 

  7416. }

    7417. 

  7417. 

    7418. 

  7418.     //

    7419. 

  7419.     // Check if a field is part of Reverse Captcha processing.

    7420. 

  7420.     //

    7421. 

  7421. function    IsReverseCaptchaField($s_name)

    7422. 

  7422. {

    7423. 

  7423.     global  $ATTACK_DETECTION_REVERSE_CAPTCHA;

    7424. 

  7424. 

    7425. 

  7425.     return (isset($ATTACK_DETECTION_REVERSE_CAPTCHA[$s_name]));

    7426. 

  7426. }

    7427. 

  7427. 

    7428. 

  7428.     //

    7429. 

  7429.     // Process a field

    7430. 

  7430.     //

    7431. 

  7431. function ProcessField($s_name,$raw_value,&$a_order,&$a_fields,&$a_raw_fields)

    7432. 

  7432. {

    7433. 

  7433.     global  $FORMATTED_INPUT;

    7434. 

  7434. 

    7435. 

  7435.         //

    7436. 

  7436.         // fields go into an array of special values or an array of other values

    7437. 

  7437.         // or get completely ignored.

    7438. 

  7438.         //

    7439. 

  7439.     $b_ignore = $b_special = false;

    7440. 

  7440.     if (IsSpecialField($s_name))

    7441. 

  7441.     {

    7442. 

  7442.         SetSpecialField($s_name,$raw_value);

    7443. 

  7443.         $b_special = true;

    7444. 

  7444.     }

    7445. 

  7445.         //

    7446. 

  7446.         // check for multiple valued special fields

    7447. 

  7447.         //

    7448. 

  7448.     if (($a_multi_fld = IsSpecialMultiField($s_name)) !== false)

    7449. 

  7449.     {

    7450. 

  7450.         SetSpecialMultiField($a_multi_fld[0],$a_multi_fld[1],$raw_value);

    7451. 

  7451.         $b_special = true;

    7452. 

  7452.     }

    7453. 

  7453.     if (!$b_special)

    7454. 

  7454.     {

    7455. 

  7455.         if (IsReverseCaptchaField($s_name))

    7456. 

  7456.             $b_ignore = true;

    7457. 

  7457.     }

    7458. 

  7458.     if (!$b_special && !$b_ignore)

    7459. 

  7459.     {

    7460. 

  7460.             //

    7461. 

  7461.             // return the raw value unchanged in the $a_raw_fields array

    7462. 

  7462.             //

    7463. 

  7463.         $a_raw_fields[$s_name] = $raw_value;

    7464. 

  7464.             //

    7465. 

  7465.             // handle checkboxes and multiple-selection lists

    7466. 

  7466.             // Thanks go to Theodore Boardman for the suggestion

    7467. 

  7467.             // and initial working code.

    7468. 

  7468.             //

    7469. 

  7469.         if (is_array($raw_value))

    7470. 

  7470.         {

    7471. 

  7471.             if (empty($raw_value))

    7472. 

  7472.                 $s_cleaned_value = "";

    7473. 

  7473.             else

    7474. 

  7474.             {

    7475. 

  7475.                 $a_cleaned_values = CleanValue($raw_value);

    7476. 

  7476.                     //

    7477. 

  7477.                     // the output is a comma separated list of values for the

    7478. 

  7478.                     // checkbox.  For example,

    7479. 

  7479.                     //          events: Diving,Cycling,Running

    7480. 

  7480.                     //

    7481. 

  7481.                     // Set the clean value to the list of cleaned checkbox

    7482. 

  7482.                     // values.

    7483. 

  7483.                     // First, remove any commas in the values themselves.

    7484. 

  7484.                     //

    7485. 

  7485.                 $a_cleaned_values = str_replace(",","",$a_cleaned_values);

    7486. 

  7486.                 $s_cleaned_value = implode(",",$a_cleaned_values);

    7487. 

  7487.             }

    7488. 

  7488.         }

    7489. 

  7489.         else

    7490. 

  7490.         {

    7491. 

  7491.                 //

    7492. 

  7492.                 // NOTE: there is a minor bug here now that we support

    7493. 

  7493.                 // $FORM_INI_FILE. The INI file is processed at the end

    7494. 

  7494.                 // so if you set the mail_options below in the INI file they

    7495. 

  7495.                 // won't get processed here.  This means you must set

    7496. 

  7496.                 // the following mail_options in the HTML form for now.

    7497. 

  7497.                 // (To be fixed at a later date.  RJR 17-Feb-06).

    7498. 

  7498.                 //

    7499. 

  7499. 

    7500. 

  7500.                 //

    7501. 

  7501.                 // if the form specifies the "KeepLines" option,

    7502. 

  7502.                 // don't strip new lines

    7503. 

  7503.                 //

    7504. 

  7504.             if (IsMailOptionSet("KeepLines") && strpos($raw_value,"\n") !== false)

    7505. 

  7505.             {

    7506. 

  7506.                     //

    7507. 

  7507.                     // truncate first

    7508. 

  7508.                     //

    7509. 

  7509.                 $s_truncated = substr("$raw_value",0,MAXSTRING);

    7510. 

  7510.                     //

    7511. 

  7511.                     // split into lines, clean each individual line,

    7512. 

  7512.                     // then put it back together again

    7513. 

  7513.                     //

    7514. 

  7514.                 $a_lines = explode("\n",$s_truncated);

    7515. 

  7515.                 $a_lines = CleanValue($a_lines);

    7516. 

  7516.                 $s_cleaned_value = implode(BODY_LF,$a_lines);

    7517. 

  7517.                     //

    7518. 

  7518.                     // and, for this special case, prepend a new line

    7519. 

  7519.                     // so that the value is shown on a fresh line

    7520. 

  7520.                     //

    7521. 

  7521.                 $s_cleaned_value = BODY_LF.$s_cleaned_value;

    7522. 

  7522.             }

    7523. 

  7523.             else

    7524. 

  7524.                 $s_cleaned_value = CleanValue($raw_value);

    7525. 

  7525.         }

    7526. 

  7526.             //

    7527. 

  7527.             // if the form specifies the "NoEmpty" option, skip

    7528. 

  7528.             // empty values.

    7529. 

  7529.             //

    7530. 

  7530.         if (!IsMailOptionSet("NoEmpty") || !FieldManager::IsEmpty($s_cleaned_value))

    7531. 

  7531.             if (!IsMailExcluded($s_name))

    7532. 

  7532.             {

    7533. 

  7533.                     //

    7534. 

  7534.                     // by default, we maintain the order as passed in

    7535. 

  7535.                     // the HTTP request

    7536. 

  7536.                     //

    7537. 

  7537.                 $a_order[] = $s_name;

    7538. 

  7538.                 $a_fields[$s_name] = $s_cleaned_value;

    7539. 

  7539.             }

    7540. 

  7540. 

    7541. 

  7541.             //

    7542. 

  7542.             // add to the $FORMATTED_INPUT array for debugging and

    7543. 

  7543.             // error reporting

    7544. 

  7544.             //

    7545. 

  7545.         array_push($FORMATTED_INPUT,"$s_name: '$s_cleaned_value'");

    7546. 

  7546.     }

    7547. 

  7547. }

    7548. 

  7548. 

    7549. 

  7549.     //

    7550. 

  7550.     // Parse the input variables and return:

    7551. 

  7551.     //  1. an array that specifies the required field order in the output

    7552. 

  7552.     //  2. an array containing the non-special cleaned field values indexed

    7553. 

  7553.     //     by field name.

    7554. 

  7554.     //  3. an array containing the non-special raw field values indexed by

    7555. 

  7555.     //     field name.

    7556. 

  7556.     //

    7557. 

  7557. function ParseInput($a_vars)

    7558. 

  7558. {

    7559. 

  7559.     $a_order = array();

    7560. 

  7560.     $a_fields = array();

    7561. 

  7561.     $a_raw_fields = array();

    7562. 

  7562.         //

    7563. 

  7563.         // scan the array of values passed in (name-value pairs) and

    7564. 

  7564.         // produce slightly formatted (not HTML) textual output

    7565. 

  7565.         // and extract any special values found.

    7566. 

  7566.         //

    7567. 

  7567.     foreach ($a_vars as $s_name=>$raw_value)

    7568. 

  7568.         ProcessField($s_name,$raw_value,$a_order,$a_fields,$a_raw_fields);

    7569. 

  7569. 

    7570. 

  7570.     return (array($a_order,$a_fields,$a_raw_fields));

    7571. 

  7571. }

    7572. 

  7572. 

    7573. 

  7573.     //

    7574. 

  7574.     // Get the URL for sending to the CRM.

    7575. 

  7575.     //

    7576. 

  7576. function GetCRMURL($spec,$vars,$url)

    7577. 

  7577. {

    7578. 

  7578.     $bad = false;

    7579. 

  7579.     $list = TrimArray(explode(",",$spec));

    7580. 

  7580.     $map = array();

    7581. 

  7581.     for ($ii = 0 ; $ii < count($list) ; $ii++)

    7582. 

  7582.     {

    7583. 

  7583.         $name = $list[$ii];

    7584. 

  7584.         if ($name)

    7585. 

  7585.         {

    7586. 

  7586.                 //

    7587. 

  7587.                 // the specification must be in this format:

    7588. 

  7588.                 //      form-field-name:CRM-field-name

    7589. 

  7589.                 //

    7590. 

  7590.             if (($i_crm_name_pos = strpos($name,":")) > 0)

    7591. 

  7591.             {

    7592. 

  7592.                 $s_crm_name = substr($name,$i_crm_name_pos + 1);

    7593. 

  7593.                 $name = substr($name,0,$i_crm_name_pos);

    7594. 

  7594.                 if (isset($vars[$name]))

    7595. 

  7595.                 {

    7596. 

  7596.                     $map[] = $s_crm_name."=".urlencode($vars[$name]);

    7597. 

  7597.                     $map[] = "Orig_".$s_crm_name."=".urlencode($name);

    7598. 

  7598.                 }

    7599. 

  7599.             }

    7600. 

  7600.             else

    7601. 

  7601.             {

    7602. 

  7602.                     //

    7603. 

  7603.                     // not the right format, so just include as a parameter

    7604. 

  7604.                     // check for name=value format to choose encoding

    7605. 

  7605.                     //

    7606. 

  7606.                 $a_values = explode("=",$name);

    7607. 

  7607.                 if (count($a_values) > 1)

    7608. 

  7608.                     $map[] = urlencode($a_values[0])."=".urlencode($a_values[1]);

    7609. 

  7609.                 else

    7610. 

  7610.                     $map[] = urlencode($a_values[0]);

    7611. 

  7611.             }

    7612. 

  7612.         }

    7613. 

  7613.     }

    7614. 

  7614.     if (count($map) == 0)

    7615. 

  7615.         return ("");

    7616. 

  7616.     return (AddURLParams($url,$map,false));

    7617. 

  7617. }

    7618. 

  7618. 

    7619. 

  7619.     //

    7620. 

  7620.     // strip the HTML from a string or array of strings

    7621. 

  7621.     //

    7622. 

  7622. function StripHTML($m_value,$s_line_feed = "\n")

    7623. 

  7623. {

    7624. 

  7624.     if (is_array($m_value))

    7625. 

  7625.     {

    7626. 

  7626.         foreach ($m_value as $m_key=>$s_str)

    7627. 

  7627.             $m_value[$m_key] = StripHTML($s_str);

    7628. 

  7628.         return ($m_value);

    7629. 

  7629.     }

    7630. 

  7630.     $s_str = $m_value;

    7631. 

  7631.         //

    7632. 

  7632.         // strip HTML comments (s option means include new lines in matches)

    7633. 

  7633.         //

    7634. 

  7634.     $s_str = preg_replace('/<!--([^-]*([^-]|-([^-]|-[^>])))*-->/s','',$s_str);

    7635. 

  7635.         //

    7636. 

  7636.         // strip any scripts (i option means case-insensitive)

    7637. 

  7637.         //

    7638. 

  7638.     $s_str = preg_replace('/<script[^>]*?>.*?<\/script[^>]*?>/si','',$s_str);

    7639. 

  7639.         //

    7640. 

  7640.         // replace paragraphs with new lines (line feeds)

    7641. 

  7641.         //

    7642. 

  7642.     $s_str = preg_replace('/<p[^>]*?>/i',$s_line_feed,$s_str);

    7643. 

  7643.         //

    7644. 

  7644.         // replace breaks with new lines (line feeds)

    7645. 

  7645.         //

    7646. 

  7646.     $s_str = preg_replace('/<br[[:space:]]*\/?[[:space:]]*>/i',$s_line_feed,$s_str);

    7647. 

  7647.         //

    7648. 

  7648.         // overcome this bug: http://bugs.php.net/bug.php?id=21311

    7649. 

  7649.         //

    7650. 

  7650.     $s_str = preg_replace('/<![^>]*>/s','',$s_str);

    7651. 

  7651.         //

    7652. 

  7652.         // get rid of all HTML tags

    7653. 

  7653.         //

    7654. 

  7654.     $s_str = strip_tags($s_str);

    7655. 

  7655.     return ($s_str);

    7656. 

  7656. }

    7657. 

  7657. 

    7658. 

  7658.     //

    7659. 

  7659.     // Check for valid URL in TARGET_URLS

    7660. 

  7660.     //

    7661. 

  7661. function CheckValidURL($s_url)

    7662. 

  7662. {

    7663. 

  7663.     global  $TARGET_URLS;

    7664. 

  7664. 

    7665. 

  7665.     foreach ($TARGET_URLS as $s_prefix)

    7666. 

  7666.         if (!empty($s_prefix) &&

    7667. 

  7667.                 strtolower(substr($s_url,0,strlen($s_prefix))) ==

    7668. 

  7668.                 strtolower($s_prefix))

    7669. 

  7669.             return (true);

    7670. 

  7670.     return (false);

    7671. 

  7671. }

    7672. 

  7672. 

    7673. 

  7673.     //

    7674. 

  7674.     // Scan the given data for fields returned from the CRM.

    7675. 

  7675.     // A field has this following format:

    7676. 

  7676.     //      __FIELDNAME__=value

    7677. 

  7677.     // terminated by a line feed.

    7678. 

  7678.     //

    7679. 

  7679. function FindCRMFields($s_data)

    7680. 

  7680. {

    7681. 

  7681.     $a_ret = array();

    7682. 

  7682.     if (preg_match_all('/^__([A-Za-z][A-Za-z0-9_]*)__=(.*)$/m',$s_data,$a_matches) === false)

    7683. 

  7683.         SendAlert(GetMessage(MSG_PREG_FAILED));

    7684. 

  7684.     else

    7685. 

  7685.     {

    7686. 

  7686.         $n_matches = count($a_matches[0]);

    7687. 

  7687.     //  SendAlert("$n_matches on '$s_data'");

    7688. 

  7688.         for ($ii = 0 ; $ii < $n_matches ; $ii++)

    7689. 

  7689.             if (isset($a_matches[1][$ii]) && isset($a_matches[2][$ii]))

    7690. 

  7690.                 $a_ret[$a_matches[1][$ii]] = $a_matches[2][$ii];

    7691. 

  7691.     }

    7692. 

  7692.     return ($a_ret);

    7693. 

  7693. }

    7694. 

  7694. 

    7695. 

  7695.     //

    7696. 

  7696.     // open the given URL to send data to it, we expect the response

    7697. 

  7697.     // to contain at least '__OK__=' followed by true or false

    7698. 

  7698.     //

    7699. 

  7699. function SendToCRM($s_url,&$a_data)

    7700. 

  7700. {

    7701. 

  7701.     global  $php_errormsg;

    7702. 

  7702. 

    7703. 

  7703.     if (!CheckValidURL($s_url))

    7704. 

  7704.     {

    7705. 

  7705.         SendAlert(GetMessage(MSG_URL_INVALID,array("URL"=>$s_url)));

    7706. 

  7706.         return (false);

    7707. 

  7707.     }

    7708. 

  7708. @   $fp = fopen($s_url,"r");        // RJR: TO DO: re-implement using NetIO

    7709. 

  7709.     if ($fp === false)

    7710. 

  7710.     {

    7711. 

  7711.         SendAlert(GetMessage(MSG_URL_OPEN,array("URL"=>$s_url,

    7712. 

  7712.                                         "ERROR"=>CheckString($php_errormsg))));

    7713. 

  7713.         return (false);

    7714. 

  7714.     }

    7715. 

  7715.     $s_mesg = "";

    7716. 

  7716.     while (!feof($fp))

    7717. 

  7717.     {

    7718. 

  7718.         $s_line = fgets($fp,4096);

    7719. 

  7719.         $s_mesg .= $s_line;

    7720. 

  7720.     }

    7721. 

  7721.     fclose($fp);

    7722. 

  7722.     $s_mesg = StripHTML($s_mesg);

    7723. 

  7723.     $s_result = preg_match('/__OK__=(.*)/',$s_mesg,$a_matches);

    7724. 

  7724.     if (count($a_matches) < 2 || $a_matches[1] === "")

    7725. 

  7725.     {

    7726. 

  7726.             //

    7727. 

  7727.             // no agreed __OK__ value returned - assume system error

    7728. 

  7728.             //

    7729. 

  7729.         SendAlert(GetMessage(MSG_CRM_FAILED,array("URL"=>$s_url,

    7730. 

  7730.                                                 "MSG"=>$s_mesg)));

    7731. 

  7731.         return (false);

    7732. 

  7732.     }

    7733. 

  7733.         //

    7734. 

  7734.         // look for fields to return

    7735. 

  7735.         //

    7736. 

  7736.     $a_data = FindCRMFields($s_mesg);

    7737. 

  7737.         //

    7738. 

  7738.         // check for success or user error

    7739. 

  7739.         //

    7740. 

  7740.     switch (strtolower($a_matches[1]))

    7741. 

  7741.     {

    7742. 

  7742.     case "true":

    7743. 

  7743.         break;

    7744. 

  7744.     case "false":

    7745. 

  7745.             //

    7746. 

  7746.             // check for user error

    7747. 

  7747.             //

    7748. 

  7748.         if (isset($a_data["USERERRORCODE"]))

    7749. 

  7749.         {

    7750. 

  7750.             $s_error_code = "crm_error";

    7751. 

  7751.             $s_error_mesg = GetMessage(MSG_CRM_FORM_ERROR);

    7752. 

  7752.             $s_error_code .= $a_data["USERERRORCODE"];

    7753. 

  7753.             if (isset($a_data["USERERRORMESG"]))

    7754. 

  7754.                 $s_error_mesg = $a_data["USERERRORMESG"];

    7755. 

  7755.             UserError($s_error_code,$s_error_mesg);

    7756. 

  7756.                 // no return

    7757. 

  7757.         }

    7758. 

  7758.         return (false);

    7759. 

  7759.     }

    7760. 

  7760.     return (true);

    7761. 

  7761. }

    7762. 

  7762. 

    7763. 

  7763.     //

    7764. 

  7764.     // Split into field name and friendly name; returns an array with

    7765. 

  7765.     // two elements.

    7766. 

  7766.     // Format is:

    7767. 

  7767.     //      fieldname:Nice printable name for displaying

    7768. 

  7768.     //

    7769. 

  7769. function GetFriendlyName($s_name)

    7770. 

  7770. {

    7771. 

  7771.     if (($i_pos = strpos($s_name,':')) === false)

    7772. 

  7772.         return (array(trim($s_name),trim($s_name)));

    7773. 

  7773.     return (array(trim(substr($s_name,0,$i_pos)),trim(substr($s_name,$i_pos+1))));

    7774. 

  7774. }

    7775. 

  7775. 

    7776. 

  7776. define("REQUIREDOPS","|^!=");       // operand characters for advanced required processing

    7777. 

  7777. 

    7778. 

  7778.     //

    7779. 

  7779.     // Perform a field comparison test.

    7780. 

  7780.     //

    7781. 

  7781. function FieldTest($s_oper,$s_fld1,$s_fld2,$a_vars,&$s_error_mesg,

    7782. 

  7782.                         $s_friendly1 = "",$s_friendly2 = "")

    7783. 

  7783. {

    7784. 

  7784.     $b_ok = true;

    7785. 

  7785.         //

    7786. 

  7786.         // perform the test

    7787. 

  7787.         //

    7788. 

  7788.     switch ($s_oper)

    7789. 

  7789.     {

    7790. 

  7790.     case '&':       // both fields must be present

    7791. 

  7791.         if (!TestFieldEmpty($s_fld1,$a_vars,$s_empty1) &&

    7792. 

  7792.             !TestFieldEmpty($s_fld2,$a_vars,$s_empty2))

    7793. 

  7793.             ;       // OK

    7794. 

  7794.         else

    7795. 

  7795.         {

    7796. 

  7796.                 //

    7797. 

  7797.                 // failed

    7798. 

  7798.                 //

    7799. 

  7799.             $s_error_mesg = GetMessage(MSG_AND,array("ITEM1"=>$s_friendly1,

    7800. 

  7800.                                                     "ITEM2"=>$s_friendly2));

    7801. 

  7801.             $b_ok = false;

    7802. 

  7802.         }

    7803. 

  7803.         break;

    7804. 

  7804.     case '|':       // either field or both must be present

    7805. 

  7805.         if (!TestFieldEmpty($s_fld1,$a_vars,$s_empty1) ||

    7806. 

  7806.             !TestFieldEmpty($s_fld2,$a_vars,$s_empty2))

    7807. 

  7807.             ;       // OK

    7808. 

  7808.         else

    7809. 

  7809.         {

    7810. 

  7810.                 //

    7811. 

  7811.                 // failed

    7812. 

  7812.                 //

    7813. 

  7813.             $s_error_mesg = GetMessage(MSG_OR,array("ITEM1"=>$s_friendly1,

    7814. 

  7814.                                                     "ITEM2"=>$s_friendly2));

    7815. 

  7815.             $b_ok = false;

    7816. 

  7816.         }

    7817. 

  7817.         break;

    7818. 

  7818.     case '^':       // either field but not both must be present

    7819. 

  7819.         $b_got1 = !TestFieldEmpty($s_fld1,$a_vars,$s_empty1);

    7820. 

  7820.         $b_got2 = !TestFieldEmpty($s_fld2,$a_vars,$s_empty2);

    7821. 

  7821.         if ($b_got1 || $b_got2)

    7822. 

  7822.         {

    7823. 

  7823.             if ($b_got1 && $b_got2)

    7824. 

  7824.             {

    7825. 

  7825.                     //

    7826. 

  7826.                     // failed

    7827. 

  7827.                     //

    7828. 

  7828.                 $s_error_mesg = GetMessage(MSG_NOT_BOTH,

    7829. 

  7829.                                             array("ITEM1"=>$s_friendly1,

    7830. 

  7830.                                                   "ITEM2"=>$s_friendly2));

    7831. 

  7831.                 $b_ok = false;

    7832. 

  7832.             }

    7833. 

  7833.         }

    7834. 

  7834.         else

    7835. 

  7835.         {

    7836. 

  7836.                 //

    7837. 

  7837.                 // failed

    7838. 

  7838.                 //

    7839. 

  7839.             $s_error_mesg = GetMessage(MSG_XOR,

    7840. 

  7840.                                         array("ITEM1"=>$s_friendly1,

    7841. 

  7841.                                               "ITEM2"=>$s_friendly2));

    7842. 

  7842.             $b_ok = false;

    7843. 

  7843.         }

    7844. 

  7844.         break;

    7845. 

  7845.     case '!=':

    7846. 

  7846.     case '=':

    7847. 

  7847.         $b_got1 = !TestFieldEmpty($s_fld1,$a_vars,$s_empty1);

    7848. 

  7848.         $b_got2 = !TestFieldEmpty($s_fld2,$a_vars,$s_empty2);

    7849. 

  7849.         if ($b_got1 && $b_got2)

    7850. 

  7850.             $b_match = (GetFieldValue($s_fld1,$a_vars) ==

    7851. 

  7851.                             GetFieldValue($s_fld2,$a_vars));

    7852. 

  7852.         elseif (!$b_got1 && !$b_got2)

    7853. 

  7853.                 //

    7854. 

  7854.                 // haven't got either value - they match

    7855. 

  7855.                 //

    7856. 

  7856.             $b_match = true;

    7857. 

  7857.         else

    7858. 

  7858.                 //

    7859. 

  7859.                 // got one value, but not the other - they don't match

    7860. 

  7860.                 //

    7861. 

  7861.             $b_match = false;

    7862. 

  7862.         if ($s_oper != '=')

    7863. 

  7863.         {

    7864. 

  7864.                 //

    7865. 

  7865.                 // != operator

    7866. 

  7866.                 //

    7867. 

  7867.             $b_match = !$b_match;

    7868. 

  7868.             $s_desc = GetMessage(MSG_IS_SAME_AS,

    7869. 

  7869.                                         array("ITEM1"=>$s_friendly1,

    7870. 

  7870.                                               "ITEM2"=>$s_friendly2));

    7871. 

  7871.         }

    7872. 

  7872.         else

    7873. 

  7873.             $s_desc = GetMessage(MSG_IS_NOT_SAME_AS,

    7874. 

  7874.                                         array("ITEM1"=>$s_friendly1,

    7875. 

  7875.                                               "ITEM2"=>$s_friendly2));

    7876. 

  7876.         if (!$b_match)

    7877. 

  7877.         {

    7878. 

  7878.                 //

    7879. 

  7879.                 // failed

    7880. 

  7880.                 //

    7881. 

  7881.             $s_error_mesg = $s_desc;

    7882. 

  7882.             $b_ok = false;

    7883. 

  7883.         }

    7884. 

  7884.         break;

    7885. 

  7885.     }

    7886. 

  7886.     return ($b_ok);

    7887. 

  7887. }

    7888. 

  7888. 

    7889. 

  7889.     //

    7890. 

  7890.     // Process advanced "required" conditionals

    7891. 

  7891.     //

    7892. 

  7892. function AdvancedRequired($s_cond,$i_span,$a_vars,&$s_missing,&$a_missing_list)

    7893. 

  7893. {

    7894. 

  7894.     $b_ok = true;

    7895. 

  7895.         //

    7896. 

  7896.         // get first field name

    7897. 

  7897.         //

    7898. 

  7898.     list($s_fld1,$s_friendly1) = GetFriendlyName(substr($s_cond,0,$i_span));

    7899. 

  7899.         //

    7900. 

  7900.         // get the operator

    7901. 

  7901.         //

    7902. 

  7902.     $s_rem = substr($s_cond,$i_span);

    7903. 

  7903.     $i_span = strspn($s_rem,REQUIREDOPS);

    7904. 

  7904.     $s_oper = substr($s_rem,0,$i_span);

    7905. 

  7905.     switch ($s_oper)

    7906. 

  7906.     {

    7907. 

  7907.     case '|':

    7908. 

  7908.     case '^':

    7909. 

  7909.     case '=':

    7910. 

  7910.     case '!=':

    7911. 

  7911.             //

    7912. 

  7912.             // second component is a field name

    7913. 

  7913.             //

    7914. 

  7914.         list($s_fld2,$s_friendly2) = GetFriendlyName(substr($s_rem,$i_span));

    7915. 

  7915.         if (!FieldTest($s_oper,$s_fld1,$s_fld2,$a_vars,$s_error_mesg,

    7916. 

  7916.                                                     $s_friendly1,$s_friendly2))

    7917. 

  7917.         {

    7918. 

  7918.                 //

    7919. 

  7919.                 // failed

    7920. 

  7920.                 //

    7921. 

  7921.             $s_missing .= "$s_error_mesg\n";

    7922. 

  7922.             $a_missing_list[$s_fld1] = "$s_error_mesg";

    7923. 

  7923.             $b_ok = false;

    7924. 

  7924.         }

    7925. 

  7925.         break;

    7926. 

  7926.     default:

    7927. 

  7927.         SendAlert(GetMessage(MSG_REQD_OPER,array("OPER"=>$s_oper)));

    7928. 

  7928.         break;

    7929. 

  7929.     }

    7930. 

  7930.     return ($b_ok);

    7931. 

  7931. }

    7932. 

  7932. 

    7933. 

  7933.     //

    7934. 

  7934.     // Check the input for required values.  The list of required fields

    7935. 

  7935.     // is a comma-separated list of field names or conditionals

    7936. 

  7936.     //

    7937. 

  7937. function CheckRequired($s_reqd,$a_vars,&$s_missing,&$a_missing_list)

    7938. 

  7938. {

    7939. 

  7939.     global  $reCaptchaProcessor;

    7940. 

  7940. 

    7941. 

  7941.     $b_bad = false;

    7942. 

  7942.     $a_list = TrimArray(explode(",",$s_reqd));

    7943. 

  7943.     $s_missing = "";

    7944. 

  7944.     $a_missing_list = array();

    7945. 

  7945.     for ($ii = 0 ; $ii < count($a_list) ; $ii++)

    7946. 

  7946.     {

    7947. 

  7947.         $s_cond = $a_list[$ii];

    7948. 

  7948.         $i_len = strlen($s_cond);

    7949. 

  7949.         if ($i_len <= 0)

    7950. 

  7950.             continue;

    7951. 

  7951.         if (($i_span = strcspn($s_cond,REQUIREDOPS)) >= $i_len)

    7952. 

  7952.         {

    7953. 

  7953.                 //

    7954. 

  7954.                 // no advanced operator; just a field name

    7955. 

  7955.                 //

    7956. 

  7956.             list($s_fld,$s_friendly) = GetFriendlyName($s_cond);

    7957. 

  7957.             if (TestFieldEmpty($s_fld,$a_vars,$s_mesg))

    7958. 

  7958.             {

    7959. 

  7959.                 if ($s_mesg === "")

    7960. 

  7960.                     $s_mesg = "$s_friendly";

    7961. 

  7961.                 else

    7962. 

  7962.                     $s_mesg = "$s_friendly ($s_mesg)";

    7963. 

  7963.                 $b_bad = true;

    7964. 

  7964.                 $s_missing .= "$s_mesg\n";

    7965. 

  7965.                 $a_missing_list[$s_fld] = "$s_mesg";

    7966. 

  7966.             }

    7967. 

  7967.         }

    7968. 

  7968.         elseif (!AdvancedRequired($s_cond,$i_span,$a_vars,

    7969. 

  7969.                                     $s_missing,$a_missing_list))

    7970. 

  7970.             $b_bad = true;

    7971. 

  7971.     }

    7972. 

  7972. 

    7973. 

  7973.     global  $REQUIRE_CAPTCHA,$SPECIAL_VALUES;

    7974. 

  7974. 

    7975. 

  7975.         //

    7976. 

  7976.         // implement REQUIRE_CAPTCHA feature

    7977. 

  7977.         //

    7978. 

  7978.     if ($REQUIRE_CAPTCHA !== "")

    7979. 

  7979.     {

    7980. 

  7980.         if ($SPECIAL_VALUES["imgverify"] === "")

    7981. 

  7981.         {

    7982. 

  7982.             $s_missing .= "$REQUIRE_CAPTCHA\n";

    7983. 

  7983.             $a_missing_list[] = "$REQUIRE_CAPTCHA";

    7984. 

  7984.             $b_bad = true;

    7985. 

  7985.         }

    7986. 

  7986.     }

    7987. 

  7987.     return (!$b_bad);

    7988. 

  7988. }

    7989. 

  7989. 

    7990. 

  7990.     //

    7991. 

  7991.     // Run a condition test

    7992. 

  7992.     //

    7993. 

  7993. function RunTest($s_test,$a_vars)

    7994. 

  7994. {

    7995. 

  7995.     global  $aAlertInfo;

    7996. 

  7996. 

    7997. 

  7997.     $s_op_chars = "&|^!=~#<>";      // these are the characters for the operators

    7998. 

  7998.     $i_len = strlen($s_test);

    7999. 

  7999.     $b_ok = true;

    8000. 

  8000.     if ($i_len <= 0)

    8001. 

  8001.             //

    8002. 

  8002.             // empty test - true

    8003. 

  8003.             //

    8004. 

  8004.         ;

    8005. 

  8005.     elseif ($s_test == "!")

    8006. 

  8006.             //

    8007. 

  8007.             // test asserts false

    8008. 

  8008.             //

    8009. 

  8009.         $b_ok = false;

    8010. 

  8010.     elseif (($i_span = strcspn($s_test,$s_op_chars)) >= $i_len)

    8011. 

  8011.             //

    8012. 

  8012.             // no operator - just check field presence

    8013. 

  8013.             //

    8014. 

  8014.         $b_ok = !TestFieldEmpty($s_test,$a_vars,$s_mesg);

    8015. 

  8015.     else

    8016. 

  8016.     {

    8017. 

  8017.             //

    8018. 

  8018.             // get first field name

    8019. 

  8019.             //

    8020. 

  8020.         $s_fld1 = trim(substr($s_test,0,$i_span));

    8021. 

  8021.             //

    8022. 

  8022.             // get the operator

    8023. 

  8023.             //

    8024. 

  8024.         $s_rem = substr($s_test,$i_span);

    8025. 

  8025.         $i_span = strspn($s_rem,$s_op_chars);

    8026. 

  8026.         $s_oper = substr($s_rem,0,$i_span);

    8027. 

  8027.         switch ($s_oper)

    8028. 

  8028.         {

    8029. 

  8029.         case '&':

    8030. 

  8030.         case '|':

    8031. 

  8031.         case '^':

    8032. 

  8032.         case '=':

    8033. 

  8033.         case '!=':

    8034. 

  8034.                 //

    8035. 

  8035.                 // get the second field name

    8036. 

  8036.                 //

    8037. 

  8037.             $s_fld2 = trim(substr($s_rem,$i_span));

    8038. 

  8038.             $b_ok = FieldTest($s_oper,$s_fld1,$s_fld2,$a_vars,$s_error_mesg);

    8039. 

  8039.             break;

    8040. 

  8040.         case '~':

    8041. 

  8041.         case '!~':

    8042. 

  8042.                 //

    8043. 

  8043.                 // get the regular expression

    8044. 

  8044.                 //

    8045. 

  8045.             $s_pat = trim(substr($s_rem,$i_span));

    8046. 

  8046.             if (!TestFieldEmpty($s_fld1,$a_vars,$s_mesg))

    8047. 

  8047.                 $s_value = GetFieldValue($s_fld1,$a_vars);

    8048. 

  8048.             else

    8049. 

  8049.                 $s_value = "";

    8050. 

  8050.             //echo "<p>Pattern: '".htmlspecialchars($s_pat)."': count=".preg_match($s_pat,$s_value)."<br /></p>";

    8051. 

  8051.                 //

    8052. 

  8052.                 // match the regular expression

    8053. 

  8053.                 //

    8054. 

  8054.             if (preg_match($s_pat,$s_value) > 0)

    8055. 

  8055.                 $b_ok = ($s_oper == '~');

    8056. 

  8056.             else

    8057. 

  8057.                 $b_ok = ($s_oper == '!~');

    8058. 

  8058.             if (!$b_ok)

    8059. 

  8059.                 $aAlertInfo[] = GetMessage(MSG_PAT_FAILED,array("OPER"=>$s_oper,

    8060. 

  8060.                                                             "PAT"=>$s_pat,

    8061. 

  8061.                                                             "VALUE"=>$s_value));

    8062. 

  8062.             break;

    8063. 

  8063.         case '#=':

    8064. 

  8064.         case '#!=':

    8065. 

  8065.         case '#<':

    8066. 

  8066.         case '#>':

    8067. 

  8067.         case '#<=':

    8068. 

  8068.         case '#>=':

    8069. 

  8069.                 //

    8070. 

  8070.                 // numeric tests

    8071. 

  8071.                 //

    8072. 

  8072.             $s_num = trim(substr($s_rem,$i_span));

    8073. 

  8073.                 //

    8074. 

  8074.                 // if this is a file field, get the size of the file for

    8075. 

  8075.                 // numeric tests

    8076. 

  8076.                 //

    8077. 

  8077.             if (($s_value = GetFileSize($s_fld1)) === false)

    8078. 

  8078.                 $s_value = $a_vars[$s_fld1];

    8079. 

  8079.             if (strpos($s_num,'.') === false)

    8080. 

  8080.             {

    8081. 

  8081.                     //

    8082. 

  8082.                     // treat as integer

    8083. 

  8083.                     //

    8084. 

  8084.                 $m_num = (int) $s_num;

    8085. 

  8085.                 $m_fld = (int) $s_value;

    8086. 

  8086.             }

    8087. 

  8087.             else

    8088. 

  8088.             {

    8089. 

  8089.                     //

    8090. 

  8090.                     // treat as floating point

    8091. 

  8091.                     //

    8092. 

  8092.                 $m_num = (float) $s_num;

    8093. 

  8093.                 $m_fld = (float) $s_value;

    8094. 

  8094.             }

    8095. 

  8095.             switch ($s_oper)

    8096. 

  8096.             {

    8097. 

  8097.             case '#=':

    8098. 

  8098.                 $b_ok = ($m_fld == $m_num);

    8099. 

  8099.                 break;

    8100. 

  8100.             case '#!=':

    8101. 

  8101.                 $b_ok = ($m_fld != $m_num);

    8102. 

  8102.                 break;

    8103. 

  8103.             case '#<':

    8104. 

  8104.                 $b_ok = ($m_fld < $m_num);

    8105. 

  8105.                 break;

    8106. 

  8106.             case '#>':

    8107. 

  8107.                 $b_ok = ($m_fld > $m_num);

    8108. 

  8108.                 break;

    8109. 

  8109.             case '#<=':

    8110. 

  8110.                 $b_ok = ($m_fld <= $m_num);

    8111. 

  8111.                 break;

    8112. 

  8112.             case '#>=':

    8113. 

  8113.                 $b_ok = ($m_fld >= $m_num);

    8114. 

  8114.                 break;

    8115. 

  8115.             }

    8116. 

  8116.             break;

    8117. 

  8117.         default:

    8118. 

  8118.             SendAlert(GetMessage(MSG_COND_OPER,array("OPER"=>$s_oper)));

    8119. 

  8119.             break;

    8120. 

  8120.         }

    8121. 

  8121.     }

    8122. 

  8122.     return ($b_ok);

    8123. 

  8123. }

    8124. 

  8124. 

    8125. 

  8125.     //

    8126. 

  8126.     // Check the input for condition tests.

    8127. 

  8127.     //

    8128. 

  8128. function CheckConditions($m_conditions,$a_vars,&$s_missing,&$a_missing_list,$m_id = false)

    8129. 

  8129. {

    8130. 

  8130.     if (is_array($m_conditions))

    8131. 

  8131.     {

    8132. 

  8132.             //

    8133. 

  8133.             // Sort the conditions by their numeric value.  This ensures

    8134. 

  8134.             // conditions are executed in the right order.

    8135. 

  8135.             //

    8136. 

  8136.         ksort($m_conditions,SORT_NUMERIC);

    8137. 

  8137.         foreach ($m_conditions as $m_key=>$s_cond)

    8138. 

  8138.             if (!CheckConditions($s_cond,$a_vars,$s_missing,$a_missing_list,$m_key))

    8139. 

  8139.                 return (false);

    8140. 

  8140.         return (true);

    8141. 

  8141.     }

    8142. 

  8142.     $s_fld_name = "conditions".($m_id === false ? "" : ($m_id+1));

    8143. 

  8143.     if (!is_string($m_conditions))

    8144. 

  8144.     {

    8145. 

  8145.         SendAlert(GetMessage(MSG_INV_COND,array("FLD"=>$s_fld_name)));

    8146. 

  8146.         return (true);  // pass invalid conditions

    8147. 

  8147.     }

    8148. 

  8148.     if ($m_conditions == "")

    8149. 

  8149.         return (true);  // pass empty conditions

    8150. 

  8150.     $s_cond = $m_conditions;

    8151. 

  8151.         //

    8152. 

  8152.         // extract the separator characters

    8153. 

  8153.         //

    8154. 

  8154.     if (strlen($s_cond) < 2)

    8155. 

  8155.     {

    8156. 

  8156.         SendAlert(GetMessage(MSG_COND_CHARS,

    8157. 

  8157.                         array("FLD"=>$s_fld_name,"COND"=>$s_cond)));

    8158. 

  8158.         return (true);  // pass invalid conditions

    8159. 

  8159.     }

    8160. 

  8160.     $s_list_sep = $s_cond[0];

    8161. 

  8161.     $s_int_sep = $s_cond[1];

    8162. 

  8162.     $s_full_cond = $s_cond = substr($s_cond,2);

    8163. 

  8163.     $b_bad = false;

    8164. 

  8164.     $a_list = TrimArray(explode($s_list_sep,$s_cond));

    8165. 

  8165.     $s_missing = "";

    8166. 

  8166.     $a_missing_list = array();

    8167. 

  8167.     for ($ii = 0 ; $ii < count($a_list) ; $ii++)

    8168. 

  8168.     {

    8169. 

  8169.         $s_cond = $a_list[$ii];

    8170. 

  8170.         $i_len = strlen($s_cond);

    8171. 

  8171.         if ($i_len <= 0)

    8172. 

  8172.             continue;

    8173. 

  8173.             //

    8174. 

  8174.             // split the condition into its internal components

    8175. 

  8175.             //

    8176. 

  8176.         $a_components = TrimArray(explode($s_int_sep,$s_cond));

    8177. 

  8177.         if (count($a_components) < 5)

    8178. 

  8178.         {

    8179. 

  8179.             SendAlert(GetMessage(MSG_COND_INVALID,

    8180. 

  8180.                         array("FLD"=>$s_fld_name,"COND"=>$s_cond,

    8181. 

  8181.                               "SEP"=>$s_int_sep)));

    8182. 

  8182.                 //

    8183. 

  8183.                 // the smallest condition has 5 components

    8184. 

  8184.                 //

    8185. 

  8185.             continue;

    8186. 

  8186.         }

    8187. 

  8187.             //

    8188. 

  8188.             // first component is ignored (it's blank)

    8189. 

  8189.             //

    8190. 

  8190.         $a_components = array_slice($a_components,1);

    8191. 

  8191.         switch ($a_components[0])

    8192. 

  8192.         {

    8193. 

  8193.         case "TEST":

    8194. 

  8194.             if (count($a_components) > 5)

    8195. 

  8195.             {

    8196. 

  8196.                 SendAlert(GetMessage(MSG_COND_TEST_LONG,

    8197. 

  8197.                         array("FLD"=>$s_fld_name,"COND"=>$s_cond,

    8198. 

  8198.                               "SEP"=>$s_list_sep)));

    8199. 

  8199.                 continue;

    8200. 

  8200.             }

    8201. 

  8201.             if (!RunTest($a_components[1],$a_vars))

    8202. 

  8202.             {

    8203. 

  8203.                 $s_missing .= $a_components[2]."\n";

    8204. 

  8204.                 $a_missing_list[] = $a_components[2];

    8205. 

  8205.                 $b_bad = true;

    8206. 

  8206.             }

    8207. 

  8207.             break;

    8208. 

  8208.         case "IF":

    8209. 

  8209.             if (count($a_components) < 6)

    8210. 

  8210.             {

    8211. 

  8211.                 SendAlert(GetMessage(MSG_COND_IF_SHORT,

    8212. 

  8212.                         array("FLD"=>$s_fld_name,"COND"=>$s_cond,

    8213. 

  8213.                               "SEP"=>$s_int_sep)));

    8214. 

  8214.                 continue;

    8215. 

  8215.             }

    8216. 

  8216.             if (count($a_components) > 7)

    8217. 

  8217.             {

    8218. 

  8218.                 SendAlert(GetMessage(MSG_COND_IF_LONG,

    8219. 

  8219.                         array("FLD"=>$s_fld_name,"COND"=>$s_cond,

    8220. 

  8220.                               "SEP"=>$s_list_sep)));

    8221. 

  8221.                 continue;

    8222. 

  8222.             }

    8223. 

  8223.             if (RunTest($a_components[1],$a_vars))

    8224. 

  8224.                 $b_test = RunTest($a_components[2],$a_vars);

    8225. 

  8225.             else

    8226. 

  8226.                 $b_test = RunTest($a_components[3],$a_vars);

    8227. 

  8227.             if (!$b_test)

    8228. 

  8228.             {

    8229. 

  8229.                 $s_missing .= $a_components[4]."\n";

    8230. 

  8230.                 $a_missing_list[] = $a_components[4];

    8231. 

  8231.                 $b_bad = true;

    8232. 

  8232.             }

    8233. 

  8233.             break;

    8234. 

  8234.         default:

    8235. 

  8235.             SendAlert(GetMessage(MSG_COND_UNK,

    8236. 

  8236.                         array("FLD"=>$s_fld_name,"COND"=>$s_cond,

    8237. 

  8237.                               "CMD"=>$a_components[0])));

    8238. 

  8238.             break;

    8239. 

  8239.         }

    8240. 

  8240.     }

    8241. 

  8241.     return (!$b_bad);

    8242. 

  8242. }

    8243. 

  8243. 

    8244. 

  8244.     //

    8245. 

  8245.     // Return a formatted list of the given environment variables.

    8246. 

  8246.     //

    8247. 

  8247. function GetEnvVars($list,$s_line_feed)

    8248. 

  8248. {

    8249. 

  8249.     global  $VALID_ENV,$aServerVars;

    8250. 

  8250. 

    8251. 

  8251.     $output = "";

    8252. 

  8252.     for ($ii = 0 ; $ii < count($list) ; $ii++)

    8253. 

  8253.     {

    8254. 

  8254.         $name = $list[$ii];

    8255. 

  8255.         if ($name && array_search($name,$VALID_ENV,true) !== false)

    8256. 

  8256.         {

    8257. 

  8257.                 //

    8258. 

  8258.                 // if the environment variable is empty or non-existent, try

    8259. 

  8259.                 // looking for the value in the server vars.

    8260. 

  8260.                 //

    8261. 

  8261.             if (($s_value = getenv($name)) === "" || $s_value === false)

    8262. 

  8262.                 if (isset($aServerVars[$name]))

    8263. 

  8263.                     $s_value = $aServerVars[$name];

    8264. 

  8264.                 else

    8265. 

  8265.                     $s_value = "";

    8266. 

  8266.             $output .= $name."=".$s_value.$s_line_feed;

    8267. 

  8267.         }

    8268. 

  8268.     }

    8269. 

  8269.     return ($output);

    8270. 

  8270. }

    8271. 

  8271. 

    8272. 

  8272.     //

    8273. 

  8273.     // open a socket connection to a filter and post the data there

    8274. 

  8274.     // RJR: TO DO: re-implement using NetIO

    8275. 

  8275.     //

    8276. 

  8276. function SocketFilter($filter,$a_filter_info,$m_data)

    8277. 

  8277. {

    8278. 

  8278.     static  $b_in_here = false;

    8279. 

  8279.     global  $php_errormsg;

    8280. 

  8280. 

    8281. 

  8281.         //

    8282. 

  8282.         // prevent recursive errors

    8283. 

  8283.         //

    8284. 

  8284.     if ($b_in_here)

    8285. 

  8285.         return ("<DATA DISCARDED>");

    8286. 

  8286.     $b_in_here = true;

    8287. 

  8287. 

    8288. 

  8288.     $a_errors = array();

    8289. 

  8289.     if (!isset($a_filter_info["site"]))

    8290. 

  8290.         $a_errors[] = GetMessage(MSG_MISSING,array("ITEM"=>"site"));

    8291. 

  8291.     else

    8292. 

  8292.         $s_site = $a_filter_info["site"];

    8293. 

  8293. 

    8294. 

  8294.     if (!isset($a_filter_info["port"]))

    8295. 

  8295.         $a_errors[] = GetMessage(MSG_MISSING,array("ITEM"=>"port"));

    8296. 

  8296.     else

    8297. 

  8297.         $i_port = (int) $a_filter_info["port"];

    8298. 

  8298. 

    8299. 

  8299.     if (!isset($a_filter_info["path"]))

    8300. 

  8300.         $a_errors[] = GetMessage(MSG_MISSING,array("ITEM"=>"path"));

    8301. 

  8301.     else

    8302. 

  8302.         $s_path = $a_filter_info["path"];

    8303. 

  8303. 

    8304. 

  8304.     if (!isset($a_filter_info["params"]))

    8305. 

  8305.         $a_params = array();

    8306. 

  8306.     elseif (!is_array($a_filter_info["params"]))

    8307. 

  8307.         $a_errors[] = GetMessage(MSG_NEED_ARRAY,array("ITEM"=>"params"));

    8308. 

  8308.     else

    8309. 

  8309.         $a_params = $a_filter_info["params"];

    8310. 

  8310. 

    8311. 

  8311.     if (!empty($a_errors))

    8312. 

  8312.     {

    8313. 

  8313.         Error("bad_filter",GetMessage(MSG_FILTER_WRONG,array(

    8314. 

  8314.                             "FILTER"=>$filter,

    8315. 

  8315.                             "ERRORS"=>implode(', ',$a_errors))),false,false);

    8316. 

  8316.         exit;

    8317. 

  8317.     }

    8318. 

  8318. 

    8319. 

  8319.         //

    8320. 

  8320.         // ready to build the socket - we need a longer time limit for the

    8321. 

  8321.         // script if we're doing this; we allow 30 seconds for the connection

    8322. 

  8322.         // (should be instantaneous, especially if it's the same domain)

    8323. 

  8323.         //

    8324. 

  8324.     set_time_limit(60);

    8325. 

  8325. @   $f_sock = fsockopen($s_site,$i_port,$i_errno,$s_errstr,30);

    8326. 

  8326.     if ($f_sock === false)

    8327. 

  8327.     {

    8328. 

  8328.         Error("filter_connect",GetMessage(MSG_FILTER_CONNECT,array(

    8329. 

  8329.                             "FILTER"=>$filter,

    8330. 

  8330.                             "SITE"=>$s_site,

    8331. 

  8331.                             "ERRNUM"=>$i_errno,

    8332. 

  8332.                             "ERRSTR"=>"$s_errstr (".CheckString($php_errormsg).")")),

    8333. 

  8333.                             false,false);

    8334. 

  8334.         exit;

    8335. 

  8335.     }

    8336. 

  8336.         //

    8337. 

  8337.         // build the data to send

    8338. 

  8338.         //

    8339. 

  8339.     $m_request_data = array();

    8340. 

  8340.     $i_count = 0;

    8341. 

  8341.     foreach ($a_params as $m_var)

    8342. 

  8342.     {

    8343. 

  8343.         $i_count++;

    8344. 

  8344.             //

    8345. 

  8345.             // if the parameter spec is an array, process it specially;

    8346. 

  8346.             // it must have "name" and "file" elements

    8347. 

  8347.             //

    8348. 

  8348.         if (is_array($m_var))

    8349. 

  8349.         {

    8350. 

  8350.             if (!isset($m_var["name"]))

    8351. 

  8351.             {

    8352. 

  8352.                 Error("bad_filter",GetMessage(MSG_FILTER_PARAM,

    8353. 

  8353.                                     array("FILTER"=>$filter,

    8354. 

  8354.                                           "NUM"=>$i_count,

    8355. 

  8355.                                           "NAME"=>"name")),false,false);

    8356. 

  8356.                 fclose($f_sock);

    8357. 

  8357.                 exit;

    8358. 

  8358.             }

    8359. 

  8359.             $s_name = $m_var["name"];

    8360. 

  8360.             if (!isset($m_var["file"]))

    8361. 

  8361.             {

    8362. 

  8362.                 Error("bad_filter",GetMessage(MSG_FILTER_PARAM,

    8363. 

  8363.                                     array("FILTER"=>$filter,

    8364. 

  8364.                                           "NUM"=>$i_count,

    8365. 

  8365.                                           "NAME"=>"file")),false,false);

    8366. 

  8366.                 fclose($f_sock);

    8367. 

  8367.                 exit;

    8368. 

  8368.             }

    8369. 

  8369.                 //

    8370. 

  8370.                 // open the file and read its contents

    8371. 

  8371.                 //

    8372. 

  8372. @           $fp = fopen($m_var["file"],"r");

    8373. 

  8373.             if ($fp === false)

    8374. 

  8374.             {

    8375. 

  8375.                 Error("filter_error",GetMessage(MSG_FILTER_OPEN_FILE,

    8376. 

  8376.                                     array("FILTER"=>$filter,

    8377. 

  8377.                                           "FILE"=>$m_var["file"],

    8378. 

  8378.                                           "ERROR"=>CheckString($php_errormsg))),false,false);

    8379. 

  8379.                 fclose($f_sock);

    8380. 

  8380.                 exit;

    8381. 

  8381.             }

    8382. 

  8382.             $s_data = "";

    8383. 

  8383.             $n_lines = 0;

    8384. 

  8384.             while (!feof($fp))

    8385. 

  8385.             {

    8386. 

  8386.                 if (($s_line = fgets($fp,2048)) === false)

    8387. 

  8387.                     if (feof($fp))

    8388. 

  8388.                         break;

    8389. 

  8389.                     else

    8390. 

  8390.                     {

    8391. 

  8391.                         Error("filter_error",GetMessage(MSG_FILTER_FILE_ERROR,

    8392. 

  8392.                                     array("FILTER"=>$filter,

    8393. 

  8393.                                           "FILE"=>$m_var["file"],

    8394. 

  8394.                                           "ERROR"=>CheckString($php_errormsg),

    8395. 

  8395.                                           "NLINES"=>$n_lines)),false,false);

    8396. 

  8396.                         fclose($f_sock);

    8397. 

  8397.                         exit;

    8398. 

  8398.                     }

    8399. 

  8399.                 $s_data .= $s_line;

    8400. 

  8400.                 $n_lines++;

    8401. 

  8401.             }

    8402. 

  8402. 

    8403. 

  8403.             fclose($fp);

    8404. 

  8404.             $m_request_data[] = "$s_name=".urlencode($s_data);

    8405. 

  8405.         }

    8406. 

  8406.         else

    8407. 

  8407.             $m_request_data[] = (string) $m_var;

    8408. 

  8408.     }

    8409. 

  8409.         //

    8410. 

  8410.         // add the data

    8411. 

  8411.         //

    8412. 

  8412.     if (is_array($m_data))

    8413. 

  8413.         $m_request_data[] = "data=".urlencode(implode(BODY_LF,$m_data));

    8414. 

  8414.     else

    8415. 

  8415.         $m_request_data[] = "data=".urlencode($m_data);

    8416. 

  8416.     $s_request = implode("&",$m_request_data);

    8417. 

  8417. 

    8418. 

  8418.     if (($i_pos = strpos($s_site,"://")) !== false)

    8419. 

  8419.         $s_site_name = substr($s_site,$i_pos+3);

    8420. 

  8420.     else

    8421. 

  8421.         $s_site_name = $s_site;

    8422. 

  8422. 

    8423. 

  8423.     fputs($f_sock,"POST $s_path HTTP/1.0\r\n");

    8424. 

  8424.     fputs($f_sock,"Host: $s_site_name\r\n");

    8425. 

  8425.     fputs($f_sock,"Content-Type: application/x-www-form-urlencoded\r\n");

    8426. 

  8426.     fputs($f_sock,"Content-Length: ".strlen($s_request)."\r\n");

    8427. 

  8427.     fputs($f_sock,"\r\n");

    8428. 

  8428.     fputs($f_sock,"$s_request\r\n");

    8429. 

  8429. 

    8430. 

  8430.         //

    8431. 

  8431.         // now read the response

    8432. 

  8432.         //

    8433. 

  8433.     $m_hdr = "";

    8434. 

  8434.     $m_data = "";

    8435. 

  8435.     $b_in_hdr = true;

    8436. 

  8436.     $b_ok = false;

    8437. 

  8437.     while (!feof($f_sock))

    8438. 

  8438.     {

    8439. 

  8439.         if (($s_line = fgets($f_sock,2048)) === false)

    8440. 

  8440.             if (feof($f_sock))

    8441. 

  8441.                 break;

    8442. 

  8442.             else

    8443. 

  8443.             {

    8444. 

  8444.                 Error("filter_failed",GetMessage(MSG_FILTER_READ_ERROR,

    8445. 

  8445.                             array("FILTER"=>$filter,

    8446. 

  8446.                                   "ERROR"=>CheckString($php_errormsg))),false,false);

    8447. 

  8447.                 fclose($f_sock);

    8448. 

  8448.                 exit;

    8449. 

  8449.             }

    8450. 

  8450.             //

    8451. 

  8451.             // look for an "__OK__" line

    8452. 

  8452.             //

    8453. 

  8453.         if (trim($s_line) == "__OK__")

    8454. 

  8454.             $b_ok = true;

    8455. 

  8455.         elseif ($b_in_hdr)

    8456. 

  8456.         {

    8457. 

  8457.                 //

    8458. 

  8458.                 // blank line signals end of header

    8459. 

  8459.                 //

    8460. 

  8460.             if (trim($s_line) == "")

    8461. 

  8461.                 $b_in_hdr = false;

    8462. 

  8462.             else

    8463. 

  8463.                 $m_hdr .= $s_line;

    8464. 

  8464.         }

    8465. 

  8465.         else

    8466. 

  8466.             $m_data .= $s_line;

    8467. 

  8467.     }

    8468. 

  8468.         //

    8469. 

  8469.         // if not OK, then report error

    8470. 

  8470.         //

    8471. 

  8471.     if (!$b_ok)

    8472. 

  8472.     {

    8473. 

  8473.         Error("filter_failed",GetMessage(MSG_FILTER_NOT_OK,

    8474. 

  8474.                     array("FILTER"=>$filter,

    8475. 

  8475.                           "DATA"=>$m_data)),false,false);

    8476. 

  8476.         fclose($f_sock);

    8477. 

  8477.         exit;

    8478. 

  8478.     }

    8479. 

  8479.     fclose($f_sock);

    8480. 

  8480.     $b_in_here = false;

    8481. 

  8481.     return ($m_data);

    8482. 

  8482. }

    8483. 

  8483. 

    8484. 

  8484.     //

    8485. 

  8485.     // run data through a supported filter

    8486. 

  8486.     //

    8487. 

  8487. function Filter($filter,$m_data)

    8488. 

  8488. {

    8489. 

  8489.     global  $FILTERS,$SOCKET_FILTERS;

    8490. 

  8490.     global  $php_errormsg;

    8491. 

  8491.     static  $b_in_here = false;

    8492. 

  8492. 

    8493. 

  8493.         //

    8494. 

  8494.         // prevent recursive errors

    8495. 

  8495.         //

    8496. 

  8496.     if ($b_in_here)

    8497. 

  8497.         return ("<DATA DISCARDED>");

    8498. 

  8498.     $b_in_here = true;

    8499. 

  8499. 

    8500. 

  8500.         //

    8501. 

  8501.         // Any errors sent in an alert are flagged to not run through the

    8502. 

  8502.         // filter - this also means the user's data won't be included in the

    8503. 

  8503.         // alert.

    8504. 

  8504.         // The reason for this is that the Filter is typically an encryption

    8505. 

  8505.         // program. If the filter fails, then sending the user's data in

    8506. 

  8506.         // clear text in an alert breaks the security of having encryption

    8507. 

  8507.         // in the first place!

    8508. 

  8508.         //

    8509. 

  8509. 

    8510. 

  8510.         //

    8511. 

  8511.         // find the filter

    8512. 

  8512.         //

    8513. 

  8513.     if (!isset($FILTERS[$filter]) || $FILTERS[$filter] == "")

    8514. 

  8514.     {

    8515. 

  8515.             //

    8516. 

  8516.             // check for SOCKET_FILTERS

    8517. 

  8517.             //

    8518. 

  8518.         if (!isset($SOCKET_FILTERS[$filter]) || $SOCKET_FILTERS[$filter] == "")

    8519. 

  8519.         {

    8520. 

  8520.             ErrorWithIgnore("bad_filter",GetMessage(MSG_FILTER_UNK,

    8521. 

  8521.                         array("FILTER"=>$filter)),false,false);

    8522. 

  8522.             exit;

    8523. 

  8523.         }

    8524. 

  8524.         $m_data = SocketFilter($filter,$SOCKET_FILTERS[$filter],$m_data);

    8525. 

  8525.     }

    8526. 

  8526.     elseif ($FILTERS[$filter] == "null")

    8527. 

  8527.             //

    8528. 

  8528.             // do nothing - just return the original data unchanged

    8529. 

  8529.             //

    8530. 

  8530.         ;

    8531. 

  8531.     elseif ($FILTERS[$filter] == "csv")

    8532. 

  8532.         $m_data = BuiltinFilterCSV();

    8533. 

  8533.     else

    8534. 

  8534.     {

    8535. 

  8535.         $cmd = $FILTERS[$filter];

    8536. 

  8536.             //

    8537. 

  8537.             // get the program name - assumed to be the first blank-separated word

    8538. 

  8538.             //

    8539. 

  8539.         $a_words = preg_split('/\s+/',$cmd);

    8540. 

  8540.         $prog = $a_words[0];

    8541. 

  8541. 

    8542. 

  8542.         $s_cwd = getcwd();

    8543. 

  8543.             //

    8544. 

  8544.             // change to the directory that contains the filter program

    8545. 

  8545.             //

    8546. 

  8546.         $dirname = dirname($prog);

    8547. 

  8547.         if ($dirname != "" && $dirname != "." && !chdir($dirname))

    8548. 

  8548.         {

    8549. 

  8549.             Error("chdir_filter",GetMessage(MSG_FILTER_CHDIR,

    8550. 

  8550.                         array("DIR"=>$dirname,"FILTER"=>$filter,

    8551. 

  8551.                               "ERROR"=>CheckString($php_errormsg))),false,false);

    8552. 

  8552.             exit;

    8553. 

  8553.         }

    8554. 

  8554. 

    8555. 

  8555.             //

    8556. 

  8556.             // the output of the filter goes to a temporary file; this works

    8557. 

  8557.             // OK on Windows too, even with the Unix shell syntax.

    8558. 

  8558.             //

    8559. 

  8559.         $temp_file = GetTempName("FMF");

    8560. 

  8560.         $temp_error_file = GetTempName("FME");

    8561. 

  8561.         $cmd = "$cmd >$temp_file 2>$temp_error_file";

    8562. 

  8562.             //

    8563. 

  8563.             // start the filter

    8564. 

  8564.             //

    8565. 

  8565.         $pipe = popen($cmd,"w");

    8566. 

  8566.         if ($pipe === false)

    8567. 

  8567.         {

    8568. 

  8568.             $s_sv_err = CheckString($php_errormsg);

    8569. 

  8569.             $err = join('',file($temp_error_file));

    8570. 

  8570.             unlink($temp_file);

    8571. 

  8571.             unlink($temp_error_file);

    8572. 

  8572.             Error("filter_not_found",GetMessage(MSG_FILTER_NOTFOUND,

    8573. 

  8573.                         array("CMD"=>$cmd,"FILTER"=>$filter,

    8574. 

  8574.                               "ERROR"=>$s_sv_err)),false,false,$err);

    8575. 

  8575.             exit;

    8576. 

  8576.         }

    8577. 

  8577.             //

    8578. 

  8578.             // write the data to the filter

    8579. 

  8579.             //

    8580. 

  8580.         if (is_array($m_data))

    8581. 

  8581.             fwrite($pipe,implode(BODY_LF,$m_data));

    8582. 

  8582.         else

    8583. 

  8583.             fwrite($pipe,$m_data);

    8584. 

  8584.         if (($i_st = pclose($pipe)) != 0)

    8585. 

  8585.         {

    8586. 

  8586.             $s_sv_err = CheckString($php_errormsg);

    8587. 

  8587.             $err = join('',file($temp_error_file));

    8588. 

  8588.             unlink($temp_file);

    8589. 

  8589.             unlink($temp_error_file);

    8590. 

  8590.             Error("filter_failed",GetMessage(MSG_FILTER_ERROR,

    8591. 

  8591.                         array("FILTER"=>$filter,

    8592. 

  8592.                               "ERROR"=>$s_sv_err,

    8593. 

  8593.                               "STATUS"=>$i_st)),false,false,$err);

    8594. 

  8594.             exit;

    8595. 

  8595.         }

    8596. 

  8596.             //

    8597. 

  8597.             // read in the filter's output and return as the data to be sent

    8598. 

  8598.             //

    8599. 

  8599.         $m_data = join('',file($temp_file));

    8600. 

  8600.         unlink($temp_error_file);

    8601. 

  8601.         unlink($temp_file);

    8602. 

  8602. 

    8603. 

  8603.             //

    8604. 

  8604.             // return to previous directory

    8605. 

  8605.             //

    8606. 

  8606.         chdir($s_cwd);

    8607. 

  8607.     }

    8608. 

  8608.     $b_in_here = false;

    8609. 

  8609.     return ($m_data);

    8610. 

  8610. }

    8611. 

  8611. 

    8612. 

  8612. /*

    8613. 

  8613.  * Function:    FilterFiles

    8614. 

  8614.  * Parameters:  $a_files    list of file uploads to filter

    8615. 

  8615.  * Returns:     void

    8616. 

  8616.  * Description:     

    8617. 

  8617.  *  Run the given files through any filter for which they are specified.

    8618. 

  8618.  */

    8619. 

  8619. function    FilterFiles(&$a_files)

    8620. 

  8620. {

    8621. 

  8621.     global  $SPECIAL_VALUES;

    8622. 

  8622. 

    8623. 

  8623.     FMDebug("FilterFiles ".count($a_files));

    8624. 

  8624.     if (!GetFilterSpec($s_filter,$a_filter_list,true) || $a_filter_list === false)

    8625. 

  8625.             //

    8626. 

  8626.             // no filter or file fields to filter

    8627. 

  8627.             //

    8628. 

  8628.         return;

    8629. 

  8629.     if (($s_mime = GetFilterAttrib($s_filter,"MIME")) === false)

    8630. 

  8630.         $s_mime = "";

    8631. 

  8631.         //

    8632. 

  8632.         // now, for each file, check if it is specified in the filter list

    8633. 

  8633.         //

    8634. 

  8634.     foreach ($a_files as $s_fld=>$a_upload)

    8635. 

  8635.     {

    8636. 

  8636.         FMDebug("Checking $s_fld");

    8637. 

  8637.         if (!IsUploadedFile($a_upload))

    8638. 

  8638.         {

    8639. 

  8639.             FMDebug("Not uploaded");

    8640. 

  8640.                 //

    8641. 

  8641.                 // failed security check

    8642. 

  8642.                 //

    8643. 

  8643.             continue;

    8644. 

  8644.         }

    8645. 

  8645.         if (!in_array($s_fld,$a_filter_list,true))

    8646. 

  8646.         {

    8647. 

  8647.             FMDebug("Not to be filtered");

    8648. 

  8648.             continue;

    8649. 

  8649.         }

    8650. 

  8650.         /*** not sure what to do with this....

    8651. 

  8651.         if (isset($a_upload["error"]))

    8652. 

  8652.                 //

    8653. 

  8653.                 // there was an upload error

    8654. 

  8654.                 //

    8655. 

  8655.             continue;

    8656. 

  8656.         ***/

    8657. 

  8657.             //

    8658. 

  8658.             // this file upload has been specified for filtering

    8659. 

  8659.             //

    8660. 

  8660.         $s_file_name = $a_upload["tmp_name"];

    8661. 

  8661.             //

    8662. 

  8662.             // check if the file has been saved elsewhere

    8663. 

  8663.             //

    8664. 

  8664.         if (isset($a_upload["saved_as"]) && !empty($a_upload["saved_as"]))

    8665. 

  8665.             $s_file_name = $a_upload["saved_as"];

    8666. 

  8666.         FMDebug("File name is $s_file_name");

    8667. 

  8667.             //

    8668. 

  8668.             // read in the file

    8669. 

  8669.             //

    8670. 

  8670.         if (($s_data = ReadInFile($s_file_name,"upload")) === false)

    8671. 

  8671.             Error("filter_files",GetMessage(MSG_FILE_UPLOAD_ERR_UNK,array("ERRNO"=>"reading $s_fld")),false,false);

    8672. 

  8672.             //

    8673. 

  8673.             // filter and write it back out to the same file

    8674. 

  8674.             //

    8675. 

  8675.         $s_data = Filter($s_filter,$s_data);

    8676. 

  8676.         if (!WriteOutFile($s_file_name,$s_data,"upload"))

    8677. 

  8677.             Error("filter_files",GetMessage(MSG_FILE_UPLOAD_ERR_UNK,array("ERRNO"=>"writing $s_fld")),false,false);

    8678. 

  8678.             //

    8679. 

  8679.             // update size and MIME type for this upload

    8680. 

  8680.             //

    8681. 

  8681.         $a_upload["size"] = strlen($s_data);

    8682. 

  8682.         if ($s_mime !== "")

    8683. 

  8683.             $a_upload["type"] = $s_mime;

    8684. 

  8684.         $a_files[$s_fld] = $a_upload;

    8685. 

  8685.     }

    8686. 

  8686. }

    8687. 

  8687. 

    8688. 

  8688. /* 

    8689. 

  8689.  * Function:    ReadInFile

    8690. 

  8690.  * Parameters:  $s_file_name    the name of the file

    8691. 

  8691.  *              $s_file_error_type type of file for any error message

    8692. 

  8692.  *              $b_text         if true, read file as text

    8693. 

  8693.  * Returns:     mixed           the entire contents of the file

    8694. 

  8694.  *                              as a string, or false on error

    8695. 

  8695.  * Description:     

    8696. 

  8696.  *  Reads the contents of a file into a string.

    8697. 

  8697.  */

    8698. 

  8698. function    ReadInFile($s_file_name,$s_file_error_type,$b_text = false)

    8699. 

  8699. {

    8700. 

  8700.     global  $php_errormsg;

    8701. 

  8701. 

    8702. 

  8702.     if (($fp = @fopen($s_file_name,"r".($b_text ? "t" : "b"))) === false)

    8703. 

  8703.     {

    8704. 

  8704.         SendAlert(GetMessage(MSG_FILE_OPEN_ERROR,array("NAME"=>$s_file_name,

    8705. 

  8705.                                             "TYPE"=>"read ".$s_file_error_type,

    8706. 

  8706.                                             "ERROR"=>CheckString($php_errormsg))));

    8707. 

  8707.         return (false);

    8708. 

  8708.     }

    8709. 

  8709.     $s_data = "";

    8710. 

  8710.     while (!feof($fp))

    8711. 

  8711.         $s_data .= fread($fp,8192);

    8712. 

  8712.     @fclose($fp);

    8713. 

  8713.     return ($s_data);

    8714. 

  8714. }

    8715. 

  8715. 

    8716. 

  8716. /* 

    8717. 

  8717.  * Function:    WriteOutFile

    8718. 

  8718.  * Parameters:  $s_file_name    the name of the file

    8719. 

  8719.  *              $s_data         the data to write

    8720. 

  8720.  *              $s_file_error_type type of file for any error message

    8721. 

  8721.  *              $b_text         if true, read file as text

    8722. 

  8722.  * Returns:     bool            true on success, otherwise false

    8723. 

  8723.  * Description:     

    8724. 

  8724.  *  Writes the contents of a file from a string.

    8725. 

  8725.  */

    8726. 

  8726. function    WriteOutFile($s_file_name,$s_data,$s_file_error_type,$b_text = false)

    8727. 

  8727. {

    8728. 

  8728.     global  $php_errormsg;

    8729. 

  8729. 

    8730. 

  8730.     if (($fp = @fopen($s_file_name,"w".($b_text ? "t" : "b"))) === false)

    8731. 

  8731.     {

    8732. 

  8732.         SendAlert(GetMessage(MSG_FILE_OPEN_ERROR,array("NAME"=>$s_file_name,

    8733. 

  8733.                                             "TYPE"=>"write ".$s_file_error_type,

    8734. 

  8734.                                             "ERROR"=>CheckString($php_errormsg))));

    8735. 

  8735.         return (false);

    8736. 

  8736.     }

    8737. 

  8737.     if (fwrite($fp,$s_data) < strlen($s_data))

    8738. 

  8738.     {

    8739. 

  8739.         @fclose($fp);

    8740. 

  8740.         return (false);

    8741. 

  8741.     }

    8742. 

  8742.     @fclose($fp);

    8743. 

  8743.     return (true);

    8744. 

  8744. }

    8745. 

  8745. 

    8746. 

  8746. /*

    8747. 

  8747.  * Class:       CSVFormat

    8748. 

  8748.  * Description:     

    8749. 

  8749.  *  Manages formatting of CSV content.

    8750. 

  8750.  */

    8751. 

  8751. class   CSVFormat

    8752. 

  8752. {

    8753. 

  8753.     var         $_cSep;         /* field separator character */

    8754. 

  8754.     var         $_cQuote;       /* field quote character */

    8755. 

  8755.     var         $_cIntSep;      /* internal separator character (for lists) */

    8756. 

  8756.     var         $_sEscPolicy;   /* escape processing policy */

    8757. 

  8757.     var         $_sCleanFunc;   /* cleaning function for fields */

    8758. 

  8758. 

    8759. 

  8759.     /*

    8760. 

  8760.      * Method:      CSVFormat ctor

    8761. 

  8761.      * Parameters:  $c_sep          the field separator

    8762. 

  8762.      *              $c_quote        the quote character to use

    8763. 

  8763.      *              $c_int_sep      the internal field separator to use

    8764. 

  8764.      *              $s_esc_policy   escape processing policy to use

    8765. 

  8765.      *              $s_clean_func   a cleaning function

    8766. 

  8766.      * Returns:     n/a

    8767. 

  8767.      * Description: 

    8768. 

  8768.      *  Constructs the object.

    8769. 

  8769.      */

    8770. 

  8770.     function    CSVFormat($c_sep = ',',$c_quote = '"',$c_int_sep = ';',

    8771. 

  8771.                             $s_esc_policy = "backslash",$s_clean_func = NULL)

    8772. 

  8772.     {

    8773. 

  8773.         $this->SetSep($c_sep);

    8774. 

  8774.         $this->SetQuote($c_quote);

    8775. 

  8775.         $this->SetIntSep($c_int_sep);

    8776. 

  8776.         $this->SetEscPolicy($s_esc_policy);

    8777. 

  8777.         $this->SetCleanFunc($s_clean_func);

    8778. 

  8778.     }

    8779. 

  8779. 

    8780. 

  8780.     /*

    8781. 

  8781.      * Method:      SetEscPolicy

    8782. 

  8782.      * Parameters:  $s_esc_policy   a string specifying the escape processing

    8783. 

  8783.      *                              policy to use

    8784. 

  8784.      * Returns:     void

    8785. 

  8785.      * Description: 

    8786. 

  8786.      *  Set the escape processing policy.

    8787. 

  8787.      */

    8788. 

  8788.     function    SetEscPolicy($s_esc_policy)

    8789. 

  8789.     {

    8790. 

  8790.         switch ($s_esc_policy)

    8791. 

  8791.         {

    8792. 

  8792.         default:        /* should generate a warning */

    8793. 

  8793.         case "backslash":

    8794. 

  8794.                 $this->_sEscPolicy = "b";

    8795. 

  8795.                 break;

    8796. 

  8796.         case "double":

    8797. 

  8797.                 $this->_sEscPolicy = "d";

    8798. 

  8798.                 break;

    8799. 

  8799.         case "strip":

    8800. 

  8800.                 $this->_sEscPolicy = "s";

    8801. 

  8801.                 break;

    8802. 

  8802.         case "conv":

    8803. 

  8803.                 $this->_sEscPolicy = "c";

    8804. 

  8804.                 break;

    8805. 

  8805.         }

    8806. 

  8806.     }

    8807. 

  8807. 

    8808. 

  8808.     /*

    8809. 

  8809.      * Method:      SetSep

    8810. 

  8810.      * Parameters:  $c_sep      the separator character to use

    8811. 

  8811.      * Returns:     void

    8812. 

  8812.      * Description: 

    8813. 

  8813.      *  Set the separator character for between fields.

    8814. 

  8814.      */

    8815. 

  8815.     function    SetSep($c_sep)

    8816. 

  8816.     {

    8817. 

  8817.         $this->_cSep = $c_sep;

    8818. 

  8818.     }

    8819. 

  8819. 

    8820. 

  8820.     /*

    8821. 

  8821.      * Method:      SetQuote

    8822. 

  8822.      * Parameters:  $c_quote      the quote character to use

    8823. 

  8823.      * Returns:     void

    8824. 

  8824.      * Description: 

    8825. 

  8825.      *  Set the quote character for quoting fields.

    8826. 

  8826.      */

    8827. 

  8827.     function    SetQuote($c_quote)

    8828. 

  8828.     {

    8829. 

  8829.         $this->_cQuote = $c_quote;

    8830. 

  8830.     }

    8831. 

  8831. 

    8832. 

  8832.     /*

    8833. 

  8833.      * Method:      SetIntSep

    8834. 

  8834.      * Parameters:  $c_int_sep      the internal separator character to use

    8835. 

  8835.      * Returns:     void

    8836. 

  8836.      * Description: 

    8837. 

  8837.      *  Set the internal separator character for inside fields.

    8838. 

  8838.      */

    8839. 

  8839.     function    SetIntSep($c_int_sep)

    8840. 

  8840.     {

    8841. 

  8841.         $this->_cIntSep = $c_int_sep;

    8842. 

  8842.     }

    8843. 

  8843. 

    8844. 

  8844.     /*

    8845. 

  8845.      * Method:      SetCleanFunc

    8846. 

  8846.      * Parameters:  $s_clean_func   the name of a cleaning function (can be NULL)

    8847. 

  8847.      * Returns:     void

    8848. 

  8848.      * Description: 

    8849. 

  8849.      *  Set the cleaning function for fields.

    8850. 

  8850.      */

    8851. 

  8851.     function    SetCleanFunc($s_clean_func)

    8852. 

  8852.     {

    8853. 

  8853.         $this->_sCleanFunc = $s_clean_func;

    8854. 

  8854.     }

    8855. 

  8855. 

    8856. 

  8856.     /*

    8857. 

  8857.      * Method:      _Escape

    8858. 

  8858.      * Parameters:  $m_value    the field value; string or array of strings 

    8859. 

  8859.      * Returns:     mixed       the field value escaped according to the

    8860. 

  8860.      *                          escape processing policy

    8861. 

  8861.      * Description: 

    8862. 

  8862.      *  Escapes a field value according to the configured requirements.

    8863. 

  8863.      */

    8864. 

  8864.     function    _Escape($m_value)

    8865. 

  8865.     {

    8866. 

  8866.         switch ($this->_sEscPolicy)

    8867. 

  8867.         {

    8868. 

  8868.         default:            /* should generate an error */

    8869. 

  8869.         case "b":

    8870. 

  8870.                     /*

    8871. 

  8871.                      * 'backslash' escape policy: replace \ with \\ and

    8872. 

  8872.                      * " with \"

    8873. 

  8873.                      */

    8874. 

  8874.                 $m_value = str_replace("\\","\\\\",$m_value);

    8875. 

  8875.                 $m_value = str_replace($this->_cQuote,"\\".$this->_cQuote,

    8876. 

  8876.                                                                     $m_value);

    8877. 

  8877.                 break;

    8878. 

  8878.         case "d":

    8879. 

  8879.                     /*

    8880. 

  8880.                      * 'double' escape policy: replace " with ""

    8881. 

  8881.                      * This is suitable for Microsoft apps such as Excel

    8882. 

  8882.                      * and Access. It also meets the specification of

    8883. 

  8883.                      * RFC4180, though this RFC only specified double

    8884. 

  8884.                      * quotes whereas we handle any quote character.

    8885. 

  8885.                      */

    8886. 

  8886.                 $m_value = str_replace($this->_cQuote,

    8887. 

  8887.                                         $this->_cQuote.$this->_cQuote,$m_value);

    8888. 

  8888.                 break;

    8889. 

  8889.         case "s":

    8890. 

  8890.                     /*

    8891. 

  8891.                      * 'strip' escape policy: strip quotes

    8892. 

  8892.                      */

    8893. 

  8893.                 $m_value = str_replace($this->_cQuote,"",$m_value);

    8894. 

  8894.                 break;

    8895. 

  8895.         case "c":

    8896. 

  8896.                     /*

    8897. 

  8897.                      * 'conv' escape policy: convert quotes to the other quotes

    8898. 

  8898.                      */

    8899. 

  8899.                 switch ($this->_cQuote)

    8900. 

  8900.                 {

    8901. 

  8901.                 case '"':

    8902. 

  8902.                         /*

    8903. 

  8903.                          * convert double quotes in the data to single quotes

    8904. 

  8904.                          */

    8905. 

  8905.                     $m_value = str_replace("\"","'",$m_value);

    8906. 

  8906.                     break;

    8907. 

  8907.                 case '\'':

    8908. 

  8908.                         /*

    8909. 

  8909.                          * convert single quotes in the data to double quotes

    8910. 

  8910.                          */

    8911. 

  8911.                     $m_value = str_replace("'","\"",$m_value);

    8912. 

  8912.                     break;

    8913. 

  8913.                 default:

    8914. 

  8914.                         /*

    8915. 

  8915.                          * otherwise, leave the data unchanged

    8916. 

  8916.                          */

    8917. 

  8917.                     break;

    8918. 

  8918.                 }

    8919. 

  8919.                 break;

    8920. 

  8920.         }

    8921. 

  8921.         return ($m_value);

    8922. 

  8922.     }

    8923. 

  8923. 

    8924. 

  8924.     /*

    8925. 

  8925.      * Method:      _Format

    8926. 

  8926.      * Parameters:  $s_value    the string value to format

    8927. 

  8927.      *              $s_format   a format specification

    8928. 

  8928.      *                          a list of characters:

    8929. 

  8929.      *                              c   CleanValue

    8930. 

  8930.      *                              s   force to be a string

    8931. 

  8931.      *                              r   remove carriage returns

    8932. 

  8932.      * Returns:     string      the formatted value

    8933. 

  8933.      * Description: 

    8934. 

  8934.      *  Formats a value.

    8935. 

  8935.      */

    8936. 

  8936.     function    _Format($s_value,$s_format = "")

    8937. 

  8937.     {

    8938. 

  8938.         $s_value = $this->_Escape($s_value);

    8939. 

  8939.         $s_prefix = "";

    8940. 

  8940.             /*

    8941. 

  8941.              * now implement any special formatting to overcome

    8942. 

  8942.              * problems with importing

    8943. 

  8943.              */

    8944. 

  8944.         $i_len = strlen($s_format);

    8945. 

  8945.         for ($ii = 0 ; $ii < $i_len ; $ii++)

    8946. 

  8946.         {

    8947. 

  8947.             switch ($s_format[$ii])

    8948. 

  8948.             {

    8949. 

  8949.             case "c":

    8950. 

  8950.                     /*

    8951. 

  8951.                      * implement "c" formatting - CleanValue

    8952. 

  8952.                      */

    8953. 

  8953.                 $s_value = CleanValue($s_value);

    8954. 

  8954.                 break;

    8955. 

  8955.             case "r":

    8956. 

  8956.                     /*

    8957. 

  8957.                      * implement "r" formatting - remove

    8958. 

  8958.                      * carriage returns.  Useful for Microsoft Excel

    8959. 

  8959.                      */

    8960. 

  8960.                 $s_value = str_replace("\r","",$s_value);

    8961. 

  8961.                 break;

    8962. 

  8962.             case "s":

    8963. 

  8963.                     /*

    8964. 

  8964.                      * implement "s" formatting - force

    8965. 

  8965.                      * a value to be a string (by making it a string

    8966. 

  8966.                      * formula).  Useful for Microsoft Excel and OpenOffice

    8967. 

  8967.                      * spreadsheet, which don't understand numeric phone

    8968. 

  8968.                      * numbers, for example.

    8969. 

  8969.                      */

    8970. 

  8970.                 if (strlen($s_value) > 0)

    8971. 

  8971.                     $s_prefix = "=";

    8972. 

  8972.                 break;

    8973. 

  8973.             }

    8974. 

  8974.         }

    8975. 

  8975. 

    8976. 

  8976.         return ($s_prefix.$this->_cQuote.$s_value.$this->_cQuote);

    8977. 

  8977.     }

    8978. 

  8978. 

    8979. 

  8979.     /*

    8980. 

  8980.      * Method:      _GetColumn

    8981. 

  8981.      * Parameters:  $s_col_spec a column specification

    8982. 

  8982.      * Returns:     array       the column name and the format specifier, if

    8983. 

  8983.      *                          any

    8984. 

  8984.      * Description: 

    8985. 

  8985.      *  Returns the column name and any format specifier.

    8986. 

  8986.      */

    8987. 

  8987.     function    _GetColumn($s_col_spec)

    8988. 

  8988.     {

    8989. 

  8989.         $s_format = "";

    8990. 

  8990.         if (($i_pos = strpos($s_col_spec,":")) !== false)

    8991. 

  8991.         {

    8992. 

  8992.             $s_col_name = trim(substr($s_col_spec,0,$i_pos));

    8993. 

  8993.             $s_format = trim(substr($s_col_spec,$i_pos+1));

    8994. 

  8994.         }

    8995. 

  8995.         else

    8996. 

  8996.             $s_col_name = $s_col_spec;

    8997. 

  8997.         return (array($s_col_name,$s_format));

    8998. 

  8998.     }

    8999. 

  8999. 

    9000. 

  9000.     /*

    9001. 

  9001.      * Method:      MakeCSVRecord

    9002. 

  9002.      * Parameters:  $a_column_list  a list of column names (field names) to

    9003. 

  9003.      *                              include; can include format specifiers

    9004. 

  9004. 

    9005. 

  9005.      *              $a_vars         raw data array indexed by column name

    9006. 

  9006.      *                              (field name).

    9007. 

  9007.      *                              A data value can be a string or an array

    9008. 

  9008.      *                              of strings.

    9009. 

  9009.      * Returns:     string          the comma-separated value    

    9010. 

  9010.      * Description: 

    9011. 

  9011.      *  Creates a single CSV record for a list of columns.

    9012. 

  9012.      */

    9013. 

  9013.     function    MakeCSVRecord($a_column_list,$a_vars)

    9014. 

  9014.     {

    9015. 

  9015.         $s_rec = "";

    9016. 

  9016.         $n_columns = count($a_column_list);

    9017. 

  9017.         for ($ii = 0 ; $ii < $n_columns ; $ii++)

    9018. 

  9018.         {

    9019. 

  9019.             list($s_col_name,$s_format) = $this->_GetColumn($a_column_list[$ii]);

    9020. 

  9020.                 /*

    9021. 

  9021.                  * if a column is specified it must be included, even if there

    9022. 

  9022.                  * is no data for it.

    9023. 

  9023.                  */

    9024. 

  9024.             $s_value = GetFieldValue($s_col_name,$a_vars,$this->_cIntSep);

    9025. 

  9025.             if (isset($this->_sCleanFunc))

    9026. 

  9026.             {

    9027. 

  9027.                 $s_func = $this->_sCleanFunc;

    9028. 

  9028.                 $s_value = $s_func($s_value);

    9029. 

  9029.             }

    9030. 

  9030. 

    9031. 

  9031.             $s_value = $this->_Format($s_value,$s_format);

    9032. 

  9032.             if ($ii > 0)

    9033. 

  9033.                     /*

    9034. 

  9034.                      * prepend the separator from the second field onwards

    9035. 

  9035.                      */

    9036. 

  9036.                 $s_rec .= $this->_cSep;

    9037. 

  9037.             $s_rec .= $s_value;

    9038. 

  9038.         }

    9039. 

  9039.         return ($s_rec);

    9040. 

  9040.     }

    9041. 

  9041. 

    9042. 

  9042.     /*

    9043. 

  9043.      * Method:      MakeHeading

    9044. 

  9044.      * Parameters:  $a_column_list  a list of column names (field names) to

    9045. 

  9045.      *                              include

    9046. 

  9046.      * Returns:     string          the comma-separated heading record    

    9047. 

  9047.      * Description: 

    9048. 

  9048.      *  Creates a heading record for the CSV data.

    9049. 

  9049.      */

    9050. 

  9050.     function    MakeHeading($a_column_list)

    9051. 

  9051.     {

    9052. 

  9052.         $s_rec = "";

    9053. 

  9053.         $n_columns = count($a_column_list);

    9054. 

  9054.         for ($ii = 0 ; $ii < $n_columns ; $ii++)

    9055. 

  9055.         {

    9056. 

  9056.             list($s_col_name,$s_format) = $this->_GetColumn($a_column_list[$ii]);

    9057. 

  9057.             $s_value = $this->_Format($s_col_name);

    9058. 

  9058.             if ($ii > 0)

    9059. 

  9059.                     /*

    9060. 

  9060.                      * prepend the separator from the second field onwards

    9061. 

  9061.                      */

    9062. 

  9062.                 $s_rec .= $this->_cSep;

    9063. 

  9063.             $s_rec .= $s_value;

    9064. 

  9064.         }

    9065. 

  9065.         return ($s_rec);

    9066. 

  9066.     }

    9067. 

  9067. };

    9068. 

  9068. 

    9069. 

  9069.     /*

    9070. 

  9070.      * Built-in filter.  Generates CSV (comma separated values) content from

    9071. 

  9071.      * the submitted fields. The special field "filter_fields" determines

    9072. 

  9072.      * which fields to include in the CSV content.

    9073. 

  9073.      * The following options are support in "filter_options":

    9074. 

  9074.      *      CSVHeading  if set, includes a heading line first with the field names

    9075. 

  9075.      *      CSVSep      specifies a separator character instead of comma

    9076. 

  9076.      *      CSVIntSep   specifies an internal separator character for lists

    9077. 

  9077.      *      CSVQuote    specifies the character to use to quote each column; default

    9078. 

  9078.      *                  is double quotes

    9079. 

  9079.      *      CSVEscPolicy controls the way quotes are escaped in the data.  Supported

    9080. 

  9080.      *                  values are: backslash (the default),double,strip

    9081. 

  9081.      *      CSVRaw      if set, then the fields are recorded as raw values and

    9082. 

  9082.      *                  are *not* cleaned according to FormMail's normal field

    9083. 

  9083.      *                  cleaning process.

    9084. 

  9084.      * If the "filter_fields" field does not exist, then the "csvcolumns" field is

    9085. 

  9085.      * used instead.  If neither exist, then all fields are included along with

    9086. 

  9086.      * a Heading line.

    9087. 

  9087.      */

    9088. 

  9088. function BuiltinFilterCSV()

    9089. 

  9089. {

    9090. 

  9090.     global  $aAllRawValues,$aRawDataValues,$SPECIAL_VALUES,$CSVLINE;

    9091. 

  9091. 

    9092. 

  9092.     $b_heading = false;

    9093. 

  9093.     $a_column_list = array();

    9094. 

  9094.     $s_cols = $SPECIAL_VALUES["filter_fields"];

    9095. 

  9095.     if (!isset($s_cols) || empty($s_cols) || !is_string($s_cols))

    9096. 

  9096.     {

    9097. 

  9097.         $s_cols = $SPECIAL_VALUES["csvcolumns"];

    9098. 

  9098.         if (!isset($s_cols) || empty($s_cols) || !is_string($s_cols))

    9099. 

  9099.         {

    9100. 

  9100.                 /*

    9101. 

  9101.                  * neither filter_fields nor csvcolumns defined - get all

    9102. 

  9102.                  * columns

    9103. 

  9103.                  */

    9104. 

  9104.             $s_cols = "";

    9105. 

  9105.                 /*

    9106. 

  9106.                  * special case - include these two special fields

    9107. 

  9107.                  */

    9108. 

  9108.             $a_column_list = array("email","realname");

    9109. 

  9109.                 /*

    9110. 

  9110.                  * now include all the data fields

    9111. 

  9111.                  */

    9112. 

  9112.             $a_column_list = array_merge($a_column_list,

    9113. 

  9113.                                             array_keys($aRawDataValues));

    9114. 

  9114.             $b_heading = true;

    9115. 

  9115.         }

    9116. 

  9116.     }

    9117. 

  9117.     if (empty($a_column_list))

    9118. 

  9118.         $a_column_list = TrimArray(explode(",",$s_cols));

    9119. 

  9119. 

    9120. 

  9120.     $csv_format = new CSVFormat();

    9121. 

  9121. 

    9122. 

  9122.         /*

    9123. 

  9123.          * get the various options and set them

    9124. 

  9124.          */

    9125. 

  9125.     $m_temp = GetFilterOption("CSVQuote");

    9126. 

  9126.     if (isset($m_temp))

    9127. 

  9127.         $csv_format->SetQuote($m_temp);

    9128. 

  9128.     $m_temp = GetFilterOption("CSVSep");

    9129. 

  9129.     if (isset($m_temp))

    9130. 

  9130.         $csv_format->SetSep($m_temp);

    9131. 

  9131.     $m_temp = GetFilterOption("CSVIntSep");

    9132. 

  9132.     if (isset($m_temp))

    9133. 

  9133.         $csv_format->SetIntSep($m_temp);

    9134. 

  9134.     $m_temp = GetFilterOption("CSVEscPolicy");

    9135. 

  9135.     if (isset($m_temp))

    9136. 

  9136.         $csv_format->SetEscPolicy($m_temp);

    9137. 

  9137.     $m_temp = GetFilterOption("CSVHeading");

    9138. 

  9138.     if (isset($m_temp))

    9139. 

  9139.         $b_heading = true;

    9140. 

  9140. 

    9141. 

  9141.         /*

    9142. 

  9142.          * clean fields unless CSVRaw is specified

    9143. 

  9143.          */

    9144. 

  9144.     $m_temp = GetFilterOption("CSVRaw");

    9145. 

  9145.     if (!isset($m_temp))

    9146. 

  9146.         $csv_format->SetCleanFunc(create_function('$m_value',

    9147. 

  9147.                                     'return CleanValue($m_value);'));

    9148. 

  9148. 

    9149. 

  9149.     $s_csv = $csv_format->MakeCSVRecord($a_column_list,$aAllRawValues);

    9150. 

  9150. 

    9151. 

  9151.     if ($b_heading)

    9152. 

  9152.     {

    9153. 

  9153.         $s_head = $csv_format->MakeHeading($a_column_list);

    9154. 

  9154.             /*

    9155. 

  9155.              * return the heading and the record with $CSVLINE as record separator

    9156. 

  9156.              */

    9157. 

  9157.         return ($s_head.$CSVLINE.$s_csv.$CSVLINE);

    9158. 

  9158.     }

    9159. 

  9159.     else

    9160. 

  9160.             /*

    9161. 

  9161.              * return this record with $CSVLINE appended

    9162. 

  9162.              */

    9163. 

  9163.         return ($s_csv.$CSVLINE);

    9164. 

  9164. }

    9165. 

  9165. 

    9166. 

  9166. $aSubstituteErrors = array();

    9167. 

  9167. $SubstituteFields = NULL;

    9168. 

  9168. $sSubstituteMissing = NULL;

    9169. 

  9169. 

    9170. 

  9170.     //

    9171. 

  9171.     // Run htmlspecialchars on every value in an array.

    9172. 

  9172.     //

    9173. 

  9173. function ArrayHTMLSpecialChars($a_list)

    9174. 

  9174. {

    9175. 

  9175.     $a_new = array();

    9176. 

  9176.     foreach ($a_list as $m_key=>$m_value)

    9177. 

  9177.         if (is_array($m_value))

    9178. 

  9178.             $a_new[$m_key] = ArrayHTMLSpecialChars($m_value);

    9179. 

  9179.         else

    9180. 

  9180.             $a_new[$m_key] = htmlspecialchars($m_value);

    9181. 

  9181.     return ($a_new);

    9182. 

  9182. }

    9183. 

  9183. 

    9184. 

  9184.     //

    9185. 

  9185.     // Truncate a value based on the specified maximums.

    9186. 

  9186.     //

    9187. 

  9187. function Truncate($s_value,$n_max_chars,$n_max_lines)

    9188. 

  9188. {

    9189. 

  9189.     if ($n_max_lines > 0)

    9190. 

  9190.     {

    9191. 

  9191.         $a_lines = explode("\n",$s_value);

    9192. 

  9192.         if (count($a_lines) > $n_max_lines)

    9193. 

  9193.         {

    9194. 

  9194.             $a_lines = array_slice($a_lines,0,$n_max_lines);

    9195. 

  9195.             $s_value = implode("\n",$a_lines);

    9196. 

  9196.             $s_value .= "...";

    9197. 

  9197.         }

    9198. 

  9198.     }

    9199. 

  9199.     if ($n_max_chars > 0)

    9200. 

  9200.     {

    9201. 

  9201.         $a_lines = explode("\n",$s_value);

    9202. 

  9202.         for ($ii = 0 ; $ii < count($a_lines) ; $ii++)

    9203. 

  9203.         {

    9204. 

  9204.             $n_len = strlen($a_lines[$ii]);

    9205. 

  9205.             $s_eol = "";

    9206. 

  9206.             if (substr($a_lines[$ii],-1) == "\n")

    9207. 

  9207.             {

    9208. 

  9208.                 $n_len--;

    9209. 

  9209.                 $s_eol = "\n";

    9210. 

  9210.             }

    9211. 

  9211.             if ($n_len > $n_max_chars)

    9212. 

  9212.                 $a_lines[$ii] = substr($a_lines[$ii],0,$n_max_chars)."...".$s_eol;

    9213. 

  9213.         }

    9214. 

  9214.         $s_value = implode("\n",$a_lines);

    9215. 

  9215.     }

    9216. 

  9216.     return ($s_value);

    9217. 

  9217. }

    9218. 

  9218. 

    9219. 

  9219.     //

    9220. 

  9220.     // Worker function for SubstituteValue and SubstituteValueForPage.

    9221. 

  9221.     // Returns the value of the matched variable name.

    9222. 

  9222.     // Variables are searched for in the global $SubstituteFields.

    9223. 

  9223.     // If no such variable exists, an error is reported or the given

    9224. 

  9224.     // replacement string is used.

    9225. 

  9225.     // Errors are stored in the global $aSubstituteErrors.

    9226. 

  9226.     //

    9227. 

  9227. function SubstituteValueWorker($a_matches,$s_repl,$b_html = true)

    9228. 

  9228. {

    9229. 

  9229.     global  $aSubstituteErrors,$SubstituteFields,$SPECIAL_VALUES;

    9230. 

  9230. 

    9231. 

  9231.     $b_insert_br = true;       // option to put "<br />" tags before newlines in HTML templates

    9232. 

  9232.     $n_max_chars = 0;

    9233. 

  9233.     $n_max_lines = 0;

    9234. 

  9234.     $s_list_sep = $SPECIAL_VALUES['template_list_sep'];

    9235. 

  9235.     $b_text_subs = false;

    9236. 

  9236. 

    9237. 

  9237.     $s_name = $a_matches[0];

    9238. 

  9238.     assert(strlen($s_name) > 1 && $s_name[0] == '$');

    9239. 

  9239.     $s_name = substr($s_name,1);

    9240. 

  9240.     if (($i_len = strlen($s_name)) > 0 && $s_name[0] == '{')

    9241. 

  9241.     {

    9242. 

  9242.         assert($s_name[$i_len-1] == '}');

    9243. 

  9243.         $s_name = substr($s_name,1,-1);

    9244. 

  9244.             //

    9245. 

  9245.             // grab any processing options

    9246. 

  9246.             //

    9247. 

  9247.         $a_args = explode(":",$s_name);

    9248. 

  9248.         $s_name = $a_args[0];

    9249. 

  9249.         if (($n_args = count($a_args)) > 1)

    9250. 

  9250.         {

    9251. 

  9251.             for ($ii = 1 ; $ii < $n_args ; $ii++)

    9252. 

  9252.             {

    9253. 

  9253.                     //

    9254. 

  9254.                     // some options are followed by =X

    9255. 

  9255.                     // where X is a value

    9256. 

  9256.                     //

    9257. 

  9257.                 $s_param = "";

    9258. 

  9258.                 if (($i_pos = strpos($a_args[$ii],'=')) !== false)

    9259. 

  9259.                 {

    9260. 

  9260.                     $s_param = substr($a_args[$ii],$i_pos+1);

    9261. 

  9261.                     $s_opt = substr($a_args[$ii],0,$i_pos);

    9262. 

  9262.                 }

    9263. 

  9263.                 else

    9264. 

  9264.                     $s_opt = $a_args[$ii];

    9265. 

  9265.                 switch ($s_opt)

    9266. 

  9266.                 {

    9267. 

  9267.                 case "nobr":

    9268. 

  9268.                     $b_insert_br = false;

    9269. 

  9269.                     break;

    9270. 

  9270.                 case "chars":

    9271. 

  9271.                     if ($s_param !== "")

    9272. 

  9272.                         $n_max_chars = (int) $s_param;

    9273. 

  9273.                     break;

    9274. 

  9274.                 case "lines":

    9275. 

  9275.                     if ($s_param !== "")

    9276. 

  9276.                         $n_max_lines = (int) $s_param;

    9277. 

  9277.                     break;

    9278. 

  9278.                 case "sep":

    9279. 

  9279.                     if ($s_param !== "")

    9280. 

  9280.                         $s_list_sep = $s_param;

    9281. 

  9281.                     break;

    9282. 

  9282.                 case "subs":

    9283. 

  9283.                     $b_text_subs = true;

    9284. 

  9284.                     break;

    9285. 

  9285.                 }

    9286. 

  9286.             }

    9287. 

  9287.         }

    9288. 

  9288.     }

    9289. 

  9289.     $s_value = "";

    9290. 

  9290.     if ($SubstituteFields->IsFieldSet($s_name) &&

    9291. 

  9291.         !$SubstituteFields->TestFieldEmpty($s_name,$s_mesg))

    9292. 

  9292.     {

    9293. 

  9293.         if ($b_html)

    9294. 

  9294.                     //

    9295. 

  9295.                     // Up to and including version 8.24, the code used

    9296. 

  9296.                     // htmlspecialchars.  Version 8.28 caused UTF-8 template

    9297. 

  9297.                     // processing to break, because it started using htmlentities

    9298. 

  9298.                     // without specifying the charset.

    9299. 

  9299.                     //

    9300. 

  9300.             $s_value = $SubstituteFields->GetSafeFieldValue($s_name,$b_text_subs,$s_list_sep);

    9301. 

  9301.         else

    9302. 

  9302.             $s_value = $SubstituteFields->GetFieldValue($s_name,$s_list_sep);

    9303. 

  9303.         $s_value = Truncate($s_value,$n_max_chars,$n_max_lines);

    9304. 

  9304.         if ($b_html && $b_insert_br)

    9305. 

  9305.                 //

    9306. 

  9306.                 // Insert HTML line breaks before newlines.

    9307. 

  9307.                 //

    9308. 

  9308.             $s_value = nl2br($s_value);

    9309. 

  9309.     }

    9310. 

  9310.     elseif (isset($SPECIAL_VALUES[$s_name]))

    9311. 

  9311.     {

    9312. 

  9312.         $s_value = $b_html ?

    9313. 

  9313.                         htmlspecialchars((string) $SPECIAL_VALUES[$s_name]) :

    9314. 

  9314.                         (string) $SPECIAL_VALUES[$s_name];

    9315. 

  9315.         $s_value = Truncate($s_value,$n_max_chars,$n_max_lines);

    9316. 

  9316.     }

    9317. 

  9317.     elseif (isset($s_repl))

    9318. 

  9318.             //

    9319. 

  9319.             // If a replacement value has been specified use it, and

    9320. 

  9320.             // don't call htmlspecialchars.  This allows the use

    9321. 

  9321.             // of HTML tags in a replacement string.

    9322. 

  9322.             //

    9323. 

  9323.         $s_value = $s_repl;

    9324. 

  9324.     else

    9325. 

  9325.         $s_value = "";

    9326. 

  9326.     return ($s_value);

    9327. 

  9327. }

    9328. 

  9328. 

    9329. 

  9329.     //

    9330. 

  9330.     // Callback function for preg_replace_callback.  Returns the value

    9331. 

  9331.     // of the matched variable name.

    9332. 

  9332.     // Variables are searched for in the global $SubstituteFields.

    9333. 

  9333.     // If no such variable exists, an error is reported or an special

    9334. 

  9334.     // replacement string is used.

    9335. 

  9335.     // Errors are stored in the global $aSubstituteErrors.

    9336. 

  9336.     //

    9337. 

  9337. function SubstituteValue($a_matches)

    9338. 

  9338. {

    9339. 

  9339.     global  $sSubstituteMissing;

    9340. 

  9340. 

    9341. 

  9341.     return (SubstituteValueWorker($a_matches,$sSubstituteMissing));

    9342. 

  9342. }

    9343. 

  9343. 

    9344. 

  9344.     //

    9345. 

  9345.     // Callback function for preg_replace_callback.  Returns the value

    9346. 

  9346.     // of the matched variable name.

    9347. 

  9347.     // Variables are searched for in the global $SubstituteFields.

    9348. 

  9348.     // If no such variable exists, an error is reported or an special

    9349. 

  9349.     // replacement string is used.

    9350. 

  9350.     // Errors are stored in the global $aSubstituteErrors.

    9351. 

  9351.     //

    9352. 

  9352. function SubstituteValuePlain($a_matches)

    9353. 

  9353. {

    9354. 

  9354.     global  $sSubstituteMissing;

    9355. 

  9355. 

    9356. 

  9356.     return (SubstituteValueWorker($a_matches,$sSubstituteMissing,false));

    9357. 

  9357. }

    9358. 

  9358. 

    9359. 

  9359.     //

    9360. 

  9360.     // Callback function for preg_replace_callback.  Returns the value

    9361. 

  9361.     // of the matched variable name.

    9362. 

  9362.     // Variables are searched for in the global $SubstituteFields.

    9363. 

  9363.     // If no such variable exists, the empty string is substituted.

    9364. 

  9364.     // Errors are stored in the global $aSubstituteErrors.

    9365. 

  9365.     //

    9366. 

  9366. function SubstituteValueForPage($a_matches)

    9367. 

  9367. {

    9368. 

  9368.     return (SubstituteValueWorker($a_matches,""));

    9369. 

  9369. }

    9370. 

  9370. 

    9371. 

  9371.     //

    9372. 

  9372.     // Callback function for preg_replace_callback.  Returns

    9373. 

  9373.     // exactly what was matched.

    9374. 

  9374.     //

    9375. 

  9375. function SubstituteValueDummy($a_matches)

    9376. 

  9376. {

    9377. 

  9377.     return ($a_matches[0]);

    9378. 

  9378. }

    9379. 

  9379. 

    9380. 

  9380.     //

    9381. 

  9381.     // Process the given HTML template and fill the fields.

    9382. 

  9382.     //

    9383. 

  9383. function DoProcessTemplate($s_dir,$s_url,$s_template,&$a_lines,

    9384. 

  9384.                             $a_values,$s_missing,$s_subs_func)

    9385. 

  9385. {

    9386. 

  9386.     global  $aSubstituteErrors,$SubstituteFields,$sSubstituteMissing;

    9387. 

  9387. 

    9388. 

  9388.     if (($a_template_lines = LoadTemplate($s_template,$s_dir,

    9389. 

  9389.                                             $s_url,true)) === false)

    9390. 

  9390.         return (false);

    9391. 

  9391.     FMDebug("Template '$s_template' contains ".count($a_template_lines)." lines");

    9392. 

  9392. 

    9393. 

  9393.     $b_ok = true;

    9394. 

  9394.         //

    9395. 

  9395.         // initialize the errors list

    9396. 

  9396.         //

    9397. 

  9397.     $aSubstituteErrors = array();

    9398. 

  9398.         //

    9399. 

  9399.         // initialize the values

    9400. 

  9400.         //

    9401. 

  9401.     $SubstituteFields = new FieldManager($a_values,array());

    9402. 

  9402.     $sSubstituteMissing = $s_missing;

    9403. 

  9403. 

    9404. 

  9404.     foreach ($a_template_lines as $s_line)

    9405. 

  9405.     {

    9406. 

  9406.             //

    9407. 

  9407.             // search for words in these forms:

    9408. 

  9408.             //      $word

    9409. 

  9409.             //      ${word:options}

    9410. 

  9410.             // where word begins with an alphabetic character and

    9411. 

  9411.             // consists of alphanumeric and underscore

    9412. 

  9412.             //

    9413. 

  9413.         $a_lines[] = preg_replace_callback('/\$[a-z][a-z0-9_]*|\$\{[a-z][a-z0-9_]*(:[^\}]*)*\}/i',

    9414. 

  9414.                                             $s_subs_func,$s_line);

    9415. 

  9415.     }

    9416. 

  9416. 

    9417. 

  9417.     FMDebug("DoProcessTemplate error count=".count($aSubstituteErrors));

    9418. 

  9418.     if (count($aSubstituteErrors) != 0)

    9419. 

  9419.     {

    9420. 

  9420.         SendAlert(GetMessage(MSG_TEMPLATE_ERRORS,array("NAME"=>$s_template)).

    9421. 

  9421.                             implode("\n",$aSubstituteErrors));

    9422. 

  9422.         $b_ok = false;

    9423. 

  9423.     }

    9424. 

  9424.     global  $FMCTemplProc;

    9425. 

  9425. 

    9426. 

  9426.         //

    9427. 

  9427.         // note that it's possible for an old version of FormMail Computation

    9428. 

  9428.         // module to get loaded which doesn't provide FMCTemplProc

    9429. 

  9429.         //

    9430. 

  9430.     if ($b_ok && ADVANCED_TEMPLATES && isset($FMCTemplProc))

    9431. 

  9431.     {

    9432. 

  9432.         $s_buf = implode("\n",$a_lines);

    9433. 

  9433.             /*

    9434. 

  9434.              * Look for a string that means we can skip advanced template

    9435. 

  9435.              * processing on this template.  The string is "FormMail-Basic-Template".

    9436. 

  9436.              */

    9437. 

  9437.         if (strpos($s_buf,"FormMail-Basic-Template") === FALSE)

    9438. 

  9438.         {

    9439. 

  9439.             $a_mesgs = array();

    9440. 

  9440.             /*foreach ($a_lines as $i_lno=>$s_line)

    9441. 

  9441.                 if (strpos($s_line,"\n") !== false)

    9442. 

  9442.                     SendAlert("Line $i_lno has a newline");*/

    9443. 

  9443.             set_time_limit(60);

    9444. 

  9444.             if (($m_result = $FMCTemplProc->Process($s_buf,$a_mesgs)) === false)

    9445. 

  9445.             {

    9446. 

  9446.                 $s_msgs = "\n";

    9447. 

  9447.                 foreach ($a_mesgs as $a_msg)

    9448. 

  9448.                 {

    9449. 

  9449.                     $s_msgs .= "Line ".$a_msg["LINE"];

    9450. 

  9450.                     $s_msgs .= ", position ".$a_msg["CHAR"].": ";

    9451. 

  9451.                     $s_msgs .= $a_msg["MSG"]."\n";

    9452. 

  9452.                 }

    9453. 

  9453.                 Error("fmadvtemplates",GetMessage(MSG_TEMPL_PROC,

    9454. 

  9454.                             array("ERRORS"=>$s_msgs)),false,false);

    9455. 

  9455.                 $b_ok = false;

    9456. 

  9456.             }

    9457. 

  9457.             else

    9458. 

  9458.             {

    9459. 

  9459.                 /*foreach ($m_result as $i_lno=>$s_line)

    9460. 

  9460.                     if (($nn = substr_count($s_line,"\n")) > 1)

    9461. 

  9461.                         SendAlert("Result line $i_lno has $nn newlines");*/

    9462. 

  9462.                     //

    9463. 

  9463.                     // strip the new lines

    9464. 

  9464.                     //

    9465. 

  9465.                 $a_lines = explode("\n",implode("",$m_result));

    9466. 

  9466.             }

    9467. 

  9467.             $a_alerts = $FMCTemplProc->GetAlerts();

    9468. 

  9468.             if (count($a_alerts) > 0)

    9469. 

  9469.                 SendAlert(GetMessage(MSG_TEMPL_ALERT,

    9470. 

  9470.                             array("ALERTS"=>implode("\n",$a_alerts))));

    9471. 

  9471.             $a_debug = $FMCTemplProc->GetDebug();

    9472. 

  9472.             if (count($a_debug) > 0)

    9473. 

  9473.                 SendAlert(GetMessage(MSG_TEMPL_DEBUG,

    9474. 

  9474.                             array("DEBUG"=>implode("\n",$a_debug))));

    9475. 

  9475.         }

    9476. 

  9476.     }

    9477. 

  9477. 

    9478. 

  9478.     return ($b_ok);

    9479. 

  9479. }

    9480. 

  9480. 

    9481. 

  9481.     //

    9482. 

  9482.     // Process the given HTML template and fill the fields.

    9483. 

  9483.     //

    9484. 

  9484. function ProcessTemplate($s_template,&$a_lines,$a_values,$s_missing = NULL,

    9485. 

  9485.                             $s_subs_func = 'SubstituteValue')

    9486. 

  9486. {

    9487. 

  9487.     global  $TEMPLATEURL,$TEMPLATEDIR;

    9488. 

  9488. 

    9489. 

  9489.     if (empty($TEMPLATEDIR) && empty($TEMPLATEURL))

    9490. 

  9490.     {

    9491. 

  9491.         SendAlert(GetMessage(MSG_TEMPLATES));

    9492. 

  9492.         return (false);

    9493. 

  9493.     }

    9494. 

  9494.     return (DoProcessTemplate($TEMPLATEDIR,$TEMPLATEURL,$s_template,$a_lines,

    9495. 

  9495.                                 $a_values,$s_missing,$s_subs_func));

    9496. 

  9496. }

    9497. 

  9497. 

    9498. 

  9498.     //

    9499. 

  9499.     // Output the given HTML template after filling in the fields.

    9500. 

  9500.     //

    9501. 

  9501. function OutputTemplate($s_template,$a_values)

    9502. 

  9502. {

    9503. 

  9503.     $a_lines = array();

    9504. 

  9504.     if (!ProcessTemplate($s_template,$a_lines,$a_values,"",'SubstituteValueForPage'))

    9505. 

  9505.         Error("template_failed",GetMessage(MSG_TEMPLATE_FAILED,

    9506. 

  9506.                                     array("NAME"=>$s_template)),false,false);

    9507. 

  9507.     else

    9508. 

  9508.     {

    9509. 

  9509.         for ($ii = 0 ; $ii < count($a_lines) ; $ii++)

    9510. 

  9510.             echo $a_lines[$ii]."\n";

    9511. 

  9511.     }

    9512. 

  9512. }

    9513. 

  9513. 

    9514. 

  9514.     //

    9515. 

  9515.     // This function handles input type fields.

    9516. 

  9516.     //

    9517. 

  9517. function RemoveFieldValue($s_name,$s_buf)

    9518. 

  9518. {

    9519. 

  9519.         //

    9520. 

  9520.         // we search for:

    9521. 

  9521.         //  <input ... name="thename" ... >

    9522. 

  9522.         // and change it to:

    9523. 

  9523.         //  <!-- disabled by FormMail: input ... name="thename" ... -->

    9524. 

  9524.         //

    9525. 

  9525. 

    9526. 

  9526.         // handle name attribute first

    9527. 

  9527.     $s_pat  = '/<(\s*input[^>]*name="';

    9528. 

  9528.     $s_pat .= preg_quote($s_name,"/");

    9529. 

  9529.     $s_pat .= '"[^>]*)>';

    9530. 

  9530.     $s_pat .= '/ims';

    9531. 

  9531.     $s_buf = preg_replace($s_pat,'<!-- disabled by FormMail: $1 -->',$s_buf);

    9532. 

  9532. 

    9533. 

  9533.     return ($s_buf);

    9534. 

  9534. }

    9535. 

  9535. 

    9536. 

  9536.     //

    9537. 

  9537.     // Quote special characters in a replacement expression

    9538. 

  9538.     // for preg_replace.

    9539. 

  9539.     //

    9540. 

  9540. function RegReplaceQuote($s_value)

    9541. 

  9541. {

    9542. 

  9542.     return (str_replace('$','\\$',str_replace('\\','\\\\',$s_value)));

    9543. 

  9543. }

    9544. 

  9544. 

    9545. 

  9545.     //

    9546. 

  9546.     // This function handles input type "text" and "password"

    9547. 

  9547.     //

    9548. 

  9548. function FixInputText($s_name,$s_value,$s_buf)

    9549. 

  9549. {

    9550. 

  9550.         //

    9551. 

  9551.         // we search for:

    9552. 

  9552.         //  <input type="text" name="thename"...

    9553. 

  9553.         // and change it to:

    9554. 

  9554.         //  <input type="text" name="thename" value="thevalue" ...

    9555. 

  9555.         //

    9556. 

  9556.         // Note that the value attribute must appear *after* the

    9557. 

  9557.         // type and name attributes.

    9558. 

  9558.         //

    9559. 

  9559. 

    9560. 

  9560.         //

    9561. 

  9561.         // first strip any current value attribute for the field

    9562. 

  9562.         //

    9563. 

  9563. 

    9564. 

  9564.         //

    9565. 

  9565.         // (?:) is a grouping subpattern that does no capturing

    9566. 

  9566.         //

    9567. 

  9567. 

    9568. 

  9568.         // handle type attribute first

    9569. 

  9569.     $s_pat  = '/(<\s*input[^>]*type="(?:text|password)"[^>]*name="';

    9570. 

  9570.     $s_pat .= preg_quote($s_name,"/");

    9571. 

  9571.     $s_pat .= '"[^>]*)(value="[^"]*")([^>]*?)(\s*\/\s*)?>';

    9572. 

  9572.     $s_pat .= '/ims';

    9573. 

  9573.     $s_buf = preg_replace($s_pat,'$1$3$4>',$s_buf);

    9574. 

  9574. 

    9575. 

  9575.         // handle name attribute first

    9576. 

  9576.     $s_pat  = '/(<\s*input[^>]*name="';

    9577. 

  9577.     $s_pat .= preg_quote($s_name,"/");

    9578. 

  9578.     $s_pat .= '"[^>]*type="(?:text|password)"[^>]*)(value="[^"]*")([^>]*?)(\s*\/\s*)?>';

    9579. 

  9579.     $s_pat .= '/ims';

    9580. 

  9580.     $s_buf = preg_replace($s_pat,'$1$3$4>',$s_buf);

    9581. 

  9581. 

    9582. 

  9582.         //

    9583. 

  9583.         // now add in the new value

    9584. 

  9584.         //

    9585. 

  9585.     $s_repl  = '$1 value="'.htmlspecialchars(RegReplaceQuote($s_value)).'" $2>';

    9586. 

  9586. 

    9587. 

  9587.         // handle type attribute first

    9588. 

  9588.     $s_pat  = '/(<\s*input[^>]*type="(?:text|password)"[^>]*name="';

    9589. 

  9589.     $s_pat .= preg_quote($s_name,"/");

    9590. 

  9590.     $s_pat .= '"[^>]*?)(\s*\/\s*)?>';

    9591. 

  9591.     $s_pat .= '/ims';

    9592. 

  9592.     $s_buf = preg_replace($s_pat,$s_repl,$s_buf);

    9593. 

  9593. 

    9594. 

  9594.         // handle name attribute first

    9595. 

  9595.     $s_pat  = '/(<\s*input[^>]*name="';

    9596. 

  9596.     $s_pat .= preg_quote($s_name,"/");

    9597. 

  9597.     $s_pat .= '"[^>]*type="(?:text|password)"[^>]*?)(\s*\/\s*)?>';

    9598. 

  9598.     $s_pat .= '/ims';

    9599. 

  9599.     $s_buf = preg_replace($s_pat,$s_repl,$s_buf);

    9600. 

  9600. 

    9601. 

  9601.     return ($s_buf);

    9602. 

  9602. }

    9603. 

  9603. 

    9604. 

  9604.     //

    9605. 

  9605.     // This function handles textareas.

    9606. 

  9606.     //

    9607. 

  9607. function FixTextArea($s_name,$s_value,$s_buf)

    9608. 

  9608. {

    9609. 

  9609.         //

    9610. 

  9610.         // we search for:

    9611. 

  9611.         //  <textarea name="thename"...>value</textarea>

    9612. 

  9612.         // and change it to:

    9613. 

  9613.         //  <textarea name="thename"...>new value</textarea>

    9614. 

  9614.         //

    9615. 

  9615. 

    9616. 

  9616.     $s_pat  = '/(<\s*textarea[^>]*name="';

    9617. 

  9617.     $s_pat .= preg_quote($s_name,"/");

    9618. 

  9618.     $s_pat .= '"[^>]*)>.*?<\s*\/\s*textarea\s*>';

    9619. 

  9619.     $s_pat .= '/ims';

    9620. 

  9620.         //

    9621. 

  9621.         // we exclude the closing '>' from the match above so that

    9622. 

  9622.         // we can put it below.  We need to do this so that the replacement

    9623. 

  9623.         // string is not faulty if the value begins with a digit:

    9624. 

  9624.         //      $19 Some Street

    9625. 

  9625.         //

    9626. 

  9626.     $s_repl = '$1>'.htmlspecialchars(RegReplaceQuote($s_value)).'</textarea>';

    9627. 

  9627.     $s_buf = preg_replace($s_pat,$s_repl,$s_buf);

    9628. 

  9628. 

    9629. 

  9629.     return ($s_buf);

    9630. 

  9630. }

    9631. 

  9631. 

    9632. 

  9632.     //

    9633. 

  9633.     // This function handles radio buttons and non-array checkboxes.

    9634. 

  9634.     //

    9635. 

  9635. function FixButton($s_name,$s_value,$s_buf)

    9636. 

  9636. {

    9637. 

  9637.         //

    9638. 

  9638.         // we search for:

    9639. 

  9639.         //  <input type="radio" name="thename" value="thevalue" ...

    9640. 

  9640.         // and change it to:

    9641. 

  9641.         //  <input type="radio" name="thename" value="thevalue" checked="checked"

    9642. 

  9642.         //

    9643. 

  9643.         // Note that the value attribute must appear *after* the

    9644. 

  9644.         // type and name attributes.

    9645. 

  9645.         //

    9646. 

  9646. 

    9647. 

  9647.         //

    9648. 

  9648.         // first strip any current checked attributes

    9649. 

  9649.         //

    9650. 

  9650. 

    9651. 

  9651.         //

    9652. 

  9652.         // (?:) is a grouping subpattern that does no capturing

    9653. 

  9653.         //

    9654. 

  9654. 

    9655. 

  9655.         // handle type attribute first

    9656. 

  9656.         // match: input tag with type 'radio' or 'checkbox' with attribute

    9657. 

  9657.         // 'checked' or 'checked="checked"'

    9658. 

  9658.         //              <A NAME="PatternInfo">

    9659. 

  9659.         //      [^>]*?[^"\w] matches up to a word boundary starting with

    9660. 

  9660.         //      'checked' but not '"checked'

    9661. 

  9661.         //      (="checked"|(?=[^"\w]))? this matches:

    9662. 

  9662.         //              nothing

    9663. 

  9663.         //              ="checked"

    9664. 

  9664.         //              any character except a word character or " (without

    9665. 

  9665.         //              consuming it)

    9666. 

  9666.         //

    9667. 

  9667.     $s_pat  = '/(<\s*input[^>]*type="(?:radio|checkbox)"[^>]*name="';

    9668. 

  9668.     $s_pat .= preg_quote($s_name,"/");

    9669. 

  9669.     $s_pat .= '"[^>]*?[^"\w])checked(="checked"|(?=[^"\w]))?([^>]*?)(\s*\/\s*)?>';

    9670. 

  9670.     $s_pat .= '/ims';

    9671. 

  9671.     $s_buf = preg_replace($s_pat,'$1$3$4>',$s_buf);

    9672. 

  9672. 

    9673. 

  9673.         // handle name attribute first

    9674. 

  9674.     $s_pat  = '/(<\s*input[^>]*name="';

    9675. 

  9675.     $s_pat .= preg_quote($s_name,"/");

    9676. 

  9676.     $s_pat .= '"[^>]*type="(?:radio|checkbox)"[^>]*?[^"\w])checked(="checked"|(?=[^"\w]))?([^>]*?)(\s*\/\s*)?>';

    9677. 

  9677.     $s_pat .= '/ims';

    9678. 

  9678.     $s_buf = preg_replace($s_pat,'$1$3$4>',$s_buf);

    9679. 

  9679. 

    9680. 

  9680.         // handle type attribute first

    9681. 

  9681.     $s_pat  = '/(<\s*input[^>]*type="(?:radio|checkbox)"[^>]*name="';

    9682. 

  9682.     $s_pat .= preg_quote($s_name,"/");

    9683. 

  9683.     $s_pat .= '"[^>]*value="';

    9684. 

  9684.     $s_pat .= preg_quote($s_value,"/");

    9685. 

  9685.     $s_pat .= '")([^>]*?)(\s*\/\s*)?>';

    9686. 

  9686.     $s_pat .= '/ims';

    9687. 

  9687.     $s_buf = preg_replace($s_pat,'$1$2 checked="checked" $3>',$s_buf);

    9688. 

  9688. 

    9689. 

  9689.         // handle name attribute first

    9690. 

  9690.     $s_pat  = '/(<\s*input[^>]*name="';

    9691. 

  9691.     $s_pat .= preg_quote($s_name,"/");

    9692. 

  9692.     $s_pat .= '"[^>]*type="(?:radio|checkbox)"[^>]*value="';

    9693. 

  9693.     $s_pat .= preg_quote($s_value,"/");

    9694. 

  9694.     $s_pat .= '")([^>]*?)(\s*\/\s*)?>';

    9695. 

  9695.     $s_pat .= '/ims';

    9696. 

  9696.     $s_buf = preg_replace($s_pat,'$1$2 checked="checked" $3>',$s_buf);

    9697. 

  9697. 

    9698. 

  9698.     return ($s_buf);

    9699. 

  9699. }

    9700. 

  9700. 

    9701. 

  9701.     //

    9702. 

  9702.     // This function handles checkboxes as an array of values.

    9703. 

  9703.     //

    9704. 

  9704. function FixCheckboxes($s_name,$a_values,$s_buf)

    9705. 

  9705. {

    9706. 

  9706.     //global $aDebug;

    9707. 

  9707. 

    9708. 

  9708.         //

    9709. 

  9709.         // we search for:

    9710. 

  9710.         //  <input type="checkbox" name="thename" value="thevalue" ...

    9711. 

  9711.         // and change it to:

    9712. 

  9712.         //  <input type="checkbox" name="thename" value="thevalue" checked

    9713. 

  9713.         //

    9714. 

  9714.         // Note that the value attribute must appear *after* the

    9715. 

  9715.         // type and name attributes.

    9716. 

  9716.         //

    9717. 

  9717. 

    9718. 

  9718.         //

    9719. 

  9719.         // first strip any current checked attributes

    9720. 

  9720.         //

    9721. 

  9721.     //$aDebug[] = "FixCheckboxes: Name='$s_name'";

    9722. 

  9722. 

    9723. 

  9723.         // handle type attribute first

    9724. 

  9724.         // see <A HREF="fmbadhandler.php#PatternInfo">

    9725. 

  9725.     $s_pat  = '/(<\s*input[^>]*type="checkbox"[^>]*name="';

    9726. 

  9726.     $s_pat .= preg_quote($s_name,"/");

    9727. 

  9727.     $s_pat .= '\[]"[^>]*?[^"\w])checked(="checked"|(?=[^"\w]))?([^>]*?)(\s*\/\s*)?>';

    9728. 

  9728.     $s_pat .= '/ims';

    9729. 

  9729.     $s_buf = preg_replace($s_pat,'$1$3$4>',$s_buf);

    9730. 

  9730. 

    9731. 

  9731.         // handle name attribute first

    9732. 

  9732.     $s_pat  = '/(<\s*input[^>]*name="';

    9733. 

  9733.     $s_pat .= preg_quote($s_name,"/");

    9734. 

  9734.     $s_pat .= '\[]"[^>]*type="checkbox"[^>]*?[^"\w])checked(="checked"|(?=[^"\w]))?([^>]*?)(\s*\/\s*)?>';

    9735. 

  9735.     $s_pat .= '/ims';

    9736. 

  9736.     $s_buf = preg_replace($s_pat,'$1$3$4>',$s_buf);

    9737. 

  9737. 

    9738. 

  9738.     foreach ($a_values as $s_value)

    9739. 

  9739.     {

    9740. 

  9740.             // handle type attribute first

    9741. 

  9741.         $s_pat  = '/(<\s*input[^>]*type="checkbox"[^>]*name="';

    9742. 

  9742.         $s_pat .= preg_quote($s_name,"/");

    9743. 

  9743.         $s_pat .= '\[\]"[^>]*value="';

    9744. 

  9744.         $s_pat .= preg_quote($s_value,"/");

    9745. 

  9745.         $s_pat .= '")([^>]*?)(\s*\/\s*)?>';

    9746. 

  9746.         $s_pat .= '/ims';

    9747. 

  9747.         $s_buf = preg_replace($s_pat,'$1$2 checked="checked"$3>',$s_buf);

    9748. 

  9748.         //$aDebug[] = "Name='$s_name', pat='$s_pat'";

    9749. 

  9749. 

    9750. 

  9750.             // handle name attribute first

    9751. 

  9751.         $s_pat  = '/(<\s*input[^>]*name="';

    9752. 

  9752.         $s_pat .= preg_quote($s_name,"/");

    9753. 

  9753.         $s_pat .= '\[\]"[^>]*type="checkbox"[^>]*value="';

    9754. 

  9754.         $s_pat .= preg_quote($s_value,"/");

    9755. 

  9755.         $s_pat .= '")([^>]*?)(\s*\/\s*)?>';

    9756. 

  9756.         $s_pat .= '/ims';

    9757. 

  9757.         $s_buf = preg_replace($s_pat,'$1$2 checked="checked">',$s_buf);

    9758. 

  9758.     }

    9759. 

  9759.     return ($s_buf);

    9760. 

  9760. }

    9761. 

  9761. 

    9762. 

  9762.     //

    9763. 

  9763.     // This function handles selects.

    9764. 

  9764.     //

    9765. 

  9765. function FixSelect($s_name,$s_value,$s_buf)

    9766. 

  9766. {

    9767. 

  9767.         //

    9768. 

  9768.         // we search for:

    9769. 

  9769.         //  <select name="thename"...>

    9770. 

  9770.         //  <option value="thevalue">...</option>

    9771. 

  9771.         //  </select>

    9772. 

  9772.         //

    9773. 

  9773. 

    9774. 

  9774.     $s_pat  = '/(<\s*select[^>]*name="';

    9775. 

  9775.     $s_pat .= preg_quote($s_name,"/");

    9776. 

  9776.     $s_pat .= '".*?<\s*option[^>]*value="';

    9777. 

  9777.     $s_pat .= preg_quote($s_value,"/");

    9778. 

  9778.     $s_pat .= '"[^>]*)>';

    9779. 

  9779.     $s_pat .= '/ims';

    9780. 

  9780.     $s_repl = '$1 selected="selected">';

    9781. 

  9781. //  echo "<p>pat: ".htmlspecialchars($s_pat);

    9782. 

  9782.     $s_buf = preg_replace($s_pat,$s_repl,$s_buf);

    9783. 

  9783. 

    9784. 

  9784.     return ($s_buf);

    9785. 

  9785. }

    9786. 

  9786. 

    9787. 

  9787.     //

    9788. 

  9788.     // This function handles multiple selects.

    9789. 

  9789.     //

    9790. 

  9790. function FixMultiSelect($s_name,$a_values,$s_buf)

    9791. 

  9791. {

    9792. 

  9792.         //

    9793. 

  9793.         // we search for:

    9794. 

  9794.         //  <select name="thename"...>

    9795. 

  9795.         //  <option value="thevalue">...</option>

    9796. 

  9796.         //  </select>

    9797. 

  9797.         //

    9798. 

  9798. 

    9799. 

  9799.     foreach ($a_values as $s_value)

    9800. 

  9800.     {

    9801. 

  9801.         $s_pat  = '/(<\s*select[^>]*name="';

    9802. 

  9802.         $s_pat .= preg_quote($s_name,"/");

    9803. 

  9803.         $s_pat .= '\[\]".*?<\s*option[^>]*value="';

    9804. 

  9804.         $s_pat .= preg_quote($s_value,"/");

    9805. 

  9805.         $s_pat .= '"[^>]*)>';

    9806. 

  9806.         $s_pat .= '/ims';

    9807. 

  9807.         $s_repl = '$1 selected="selected">';

    9808. 

  9808.     //  echo "<p>pat: ".htmlspecialchars($s_pat);

    9809. 

  9809.         $s_buf = preg_replace($s_pat,$s_repl,$s_buf);

    9810. 

  9810.     }

    9811. 

  9811.     return ($s_buf);

    9812. 

  9812. }

    9813. 

  9813. 

    9814. 

  9814.     //

    9815. 

  9815.     // This function unchecks all checkboxes and select options.

    9816. 

  9816.     //

    9817. 

  9817. function UnCheckStuff($s_buf)

    9818. 

  9818. {

    9819. 

  9819.     global  $php_errormsg;

    9820. 

  9820. 

    9821. 

  9821.         //

    9822. 

  9822.         // we search for:

    9823. 

  9823.         //  <input type="checkbox" ... checked

    9824. 

  9824.         // and remove "checked" (checked="checked" is OK too)

    9825. 

  9825.         //

    9826. 

  9826.         // Note that the check attribute must appear *after* the

    9827. 

  9827.         // type attribute.

    9828. 

  9828.         // see <A HREF="fmbadhandler.php#PatternInfo">

    9829. 

  9829.         //

    9830. 

  9830. 

    9831. 

  9831.     $s_pat  = '/(<\s*input[^>]*type="checkbox"[^>]*?[^"\w])checked(="checked"|(?=[^"\w]))?([^>]*?)(\s*\/\s*)?>';

    9832. 

  9832.     $s_pat .= '/ims';

    9833. 

  9833. 

    9834. 

  9834.     $s_buf = preg_replace($s_pat,'$1$3$4>',$s_buf);

    9835. 

  9835. 

    9836. 

  9836.         //

    9837. 

  9837.         // we search for:

    9838. 

  9838.         //  <option... selected

    9839. 

  9839.         // and remove "selected" (selected="selected" is OK too)

    9840. 

  9840.         // see <A HREF="fmbadhandler.php#PatternInfo">

    9841. 

  9841.         //

    9842. 

  9842. 

    9843. 

  9843.     $s_pat  = '/(<\s*option[^>]*?[^"\w])selected(="selected"|(?=[^"\w]))?([^>]*)>';

    9844. 

  9844.     $s_pat .= '/ims';

    9845. 

  9845.     $s_buf = preg_replace($s_pat,'$1$3>',$s_buf);

    9846. 

  9846. 

    9847. 

  9847.     return ($s_buf);

    9848. 

  9848. }

    9849. 

  9849. 

    9850. 

  9850.     //

    9851. 

  9851.     // Add the user agent to the url as a parameter called USER_AGENT.

    9852. 

  9852.     // This allows dynamic web sites to know what the user's browser is.

    9853. 

  9853.     //

    9854. 

  9854. function AddUserAgent($s_url)

    9855. 

  9855. {

    9856. 

  9856.     global  $aServerVars,$aGetVars;

    9857. 

  9857. 

    9858. 

  9858.         //

    9859. 

  9859.         // check if the USER_AGENT has been passed as a URL parameter,

    9860. 

  9860.         // if so, use it

    9861. 

  9861.         //

    9862. 

  9862.     $s_agent = "";

    9863. 

  9863.     if (isset($aGetVars['USER_AGENT']) && $aGetVars['USER_AGENT'] !== "")

    9864. 

  9864.     {

    9865. 

  9865.         $s_agent = $aGetVars['USER_AGENT'];

    9866. 

  9866.                 //

    9867. 

  9867.                 // check for URL encoding, and if not, then encode it

    9868. 

  9868.                 //

    9869. 

  9869.         if (!IsURLEncoded($s_agent))

    9870. 

  9870.             $s_agent = urlencode($s_agent);

    9871. 

  9871.     }

    9872. 

  9872.     elseif (isset($aServerVars['HTTP_USER_AGENT']))

    9873. 

  9873.         $s_agent = urlencode($aServerVars['HTTP_USER_AGENT']);

    9874. 

  9874. 

    9875. 

  9875.     if ($s_agent !== "")

    9876. 

  9876.         return (AddURLParams($s_url,"USER_AGENT=$s_agent",false));

    9877. 

  9877.     else

    9878. 

  9878.         return ($s_url);

    9879. 

  9879. }

    9880. 

  9880. 

    9881. 

  9881. //

    9882. 

  9882. // Try to determine if the given string is already URL-encoded

    9883. 

  9883. //

    9884. 

  9884. function    IsURLEncoded($s_str)

    9885. 

  9885. {

    9886. 

  9886.         //

    9887. 

  9887.         // the only non-alphanumeric characters we'd expect

    9888. 

  9888.         // to see are defined as safe or extra in RFC 1738:

    9889. 

  9889.         //  safe           = "$" | "-" | "_" | "." | "+"

    9890. 

  9890.         //  extra          = "!" | "*" | "'" | "(" | ")" | ","

    9891. 

  9891.         // plus the encoding character %

    9892. 

  9892.         //

    9893. 

  9893.     if (preg_match('/[^a-z0-9$_.+!*\'(),%-]/i',$s_str,$a_matches))

    9894. 

  9894.     {

    9895. 

  9895.         FMDebug("IsURLEncoded: '$s_str' matched '".$a_matches[0]."' and is therefore not URL-encoded");

    9896. 

  9896.         return (false);

    9897. 

  9897.     }

    9898. 

  9898.     return (true);

    9899. 

  9899. }

    9900. 

  9900. 

    9901. 

  9901.     //

    9902. 

  9902.     // Sets previous values in a form.

    9903. 

  9903.     //

    9904. 

  9904. function SetPreviousValues($s_form_buf,$a_values,$a_strip = array())

    9905. 

  9905. {

    9906. 

  9906.         //

    9907. 

  9907.         // Uncheck any checkboxes and select options

    9908. 

  9908.         //

    9909. 

  9909.     $s_form_buf = UnCheckStuff($s_form_buf);

    9910. 

  9910.     foreach ($a_values as $s_name=>$m_value)

    9911. 

  9911.     {

    9912. 

  9912.         if (is_array($m_value))

    9913. 

  9913.         {

    9914. 

  9914.                 //

    9915. 

  9915.                 // note that if no values are selected for a field,

    9916. 

  9916.                 // then we will never get here for that field

    9917. 

  9917.                 //

    9918. 

  9918.             $s_form_buf = FixCheckboxes($s_name,$m_value,$s_form_buf);

    9919. 

  9919.             $s_form_buf = FixMultiSelect($s_name,$m_value,$s_form_buf);

    9920. 

  9920.         }

    9921. 

  9921.         else

    9922. 

  9922.         {

    9923. 

  9923.                 //

    9924. 

  9924.                 // Fix the field if it's an input type "text" or "password".

    9925. 

  9925.                 //

    9926. 

  9926.             $s_form_buf = FixInputText($s_name,$m_value,$s_form_buf);

    9927. 

  9927.                 //

    9928. 

  9928.                 // Fix the field if it's radio button.

    9929. 

  9929.                 //

    9930. 

  9930.             $s_form_buf = FixButton($s_name,$m_value,$s_form_buf);

    9931. 

  9931.                 //

    9932. 

  9932.                 // Fix the field if it's a "textarea".

    9933. 

  9933.                 //

    9934. 

  9934.             $s_form_buf = FixTextArea($s_name,$m_value,$s_form_buf);

    9935. 

  9935.                 //

    9936. 

  9936.                 // Fix the field if it's a "select".

    9937. 

  9937.                 //

    9938. 

  9938.             $s_form_buf = FixSelect($s_name,$m_value,$s_form_buf);

    9939. 

  9939.         }

    9940. 

  9940.     }

    9941. 

  9941.         //

    9942. 

  9942.         // Now strip particular field values.

    9943. 

  9943.         //

    9944. 

  9944.     foreach ($a_strip as $s_name)

    9945. 

  9945.         $s_form_buf = RemoveFieldValue($s_name,$s_form_buf);

    9946. 

  9946.     return ($s_form_buf);

    9947. 

  9947. }

    9948. 

  9948. 

    9949. 

  9949.     //

    9950. 

  9950.     // Open a URL, do value substitutions, and send to browser.

    9951. 

  9951.     // The a_strip array provides a list of fields (usually

    9952. 

  9952.     // hidden fields) to remove from the form (their values are

    9953. 

  9953.     // set to empty).

    9954. 

  9954.     //

    9955. 

  9955. function ProcessReturnToForm($s_url,$a_values,$a_strip = array())

    9956. 

  9956. {

    9957. 

  9957.     global  $php_errormsg;

    9958. 

  9958. 

    9959. 

  9959.         //

    9960. 

  9960.         // read the original form, and modify it to provide values

    9961. 

  9961.         // for the fields

    9962. 

  9962.         //

    9963. 

  9963.     if (!CheckValidURL($s_url))

    9964. 

  9964.         Error("invalid_url",GetMessage(MSG_RETURN_URL_INVALID,

    9965. 

  9965.                                     array("URL"=>$s_url)),false,false);

    9966. 

  9966. 

    9967. 

  9967.     $s_form_url = AddUserAgent($s_url);

    9968. 

  9968.     $s_error = "";

    9969. 

  9969.     $s_form_buf = GetURL($s_form_url,$s_error);

    9970. 

  9970.     if ($s_form_buf === false)

    9971. 

  9971.         Error("invalid_url",GetMessage(MSG_OPEN_URL,

    9972. 

  9972.                                 array("URL"=>$s_form_url,

    9973. 

  9973.                                       "ERROR"=>$s_error.": ".(isset($php_errormsg) ?

    9974. 

  9974.                                             $php_errormsg : ""))),false,false);

    9975. 

  9975. 

    9976. 

  9976.         //

    9977. 

  9977.         // Next, we replace or set actual field values.

    9978. 

  9978.         //

    9979. 

  9979.     echo SetPreviousValues($s_form_buf,$a_values,$a_strip);

    9980. 

  9980. }

    9981. 

  9981. 

    9982. 

  9982.     //

    9983. 

  9983.     // To return the URL for returning to a particular multi-page form URL.

    9984. 

  9984.     //

    9985. 

  9985. function GetReturnLink($s_this_script,$i_form_index)

    9986. 

  9986. {

    9987. 

  9987.     if (!CheckValidURL($s_this_script))

    9988. 

  9988.         Error("not_valid_url",GetMessage(MSG_RETURN_URL_INVALID,

    9989. 

  9989.                                 array("URL"=>$s_this_script)),false,false);

    9990. 

  9990. 

    9991. 

  9991.     $a_params = array();

    9992. 

  9992.     $a_params[] = "return=$i_form_index";

    9993. 

  9993.     if (isset($aServerVars["QUERY_STRING"]))

    9994. 

  9994.         $a_params[] = $aServerVars["QUERY_STRING"];

    9995. 

  9995.     $a_params[] = session_name()."=".session_id();

    9996. 

  9996.     return (AddURLParams($s_this_script,$a_params));

    9997. 

  9997. }

    9998. 

  9998. 

    9999. 

  9999.     //

    10000. 

  10000.     // Process a multi-page form template.

    10001. 

  10001.     //

    10002. 

  10002. function ProcessMultiFormTemplate($s_template,$a_values,&$a_lines)

    10003. 

  10003. {

    10004. 

  10004.     global  $MULTIFORMURL,$MULTIFORMDIR,$SPECIAL_VALUES;

    10005. 

  10005. 

    10006. 

  10006.     if (empty($MULTIFORMDIR) && empty($MULTIFORMURL))

    10007. 

  10007.     {

    10008. 

  10008.         SendAlert(GetMessage(MSG_MULTIFORM));

    10009. 

  10009.         return (false);

    10010. 

  10010.     }

    10011. 

  10011.         //

    10012. 

  10012.         // create the "this_form_url" field

    10013. 

  10013.         //

    10014. 

  10014. 

    10015. 

  10015.     $i_index = GetSession("FormIndex");

    10016. 

  10016.     $a_list = GetSession("FormList");

    10017. 

  10017.     $a_values["this_form_url"] = $a_list[$i_index]["URL"];

    10018. 

  10018.         //

    10019. 

  10019.         // get the persistent file fields

    10020. 

  10020.         //

    10021. 

  10021.     $a_values = GetSavedFileNames($a_values);

    10022. 

  10022.     //$a_values["prev_form"] = GetReturnLink($SPECIAL_VALUES["this_form"]);

    10023. 

  10023.     return (DoProcessTemplate($MULTIFORMDIR,$MULTIFORMURL,$s_template,$a_lines,

    10024. 

  10024.                             $a_values,"",'SubstituteValueForPage'));

    10025. 

  10025. }

    10026. 

  10026. 

    10027. 

  10027.     //

    10028. 

  10028.     // Output the multi-form template after filling in the fields.

    10029. 

  10029.     //

    10030. 

  10030. function OutputMultiFormTemplate($s_template,$a_values)

    10031. 

  10031. {

    10032. 

  10032.     $a_lines = array();

    10033. 

  10033.     if (!ProcessMultiFormTemplate($s_template,$a_values,$a_lines))

    10034. 

  10034.         Error("multi_form_failed",GetMessage(MSG_MULTIFORM_FAILED,

    10035. 

  10035.                                     array("NAME"=>$s_template)),false,false);

    10036. 

  10036.     else

    10037. 

  10037.     {

    10038. 

  10038.         $n_lines = count($a_lines);

    10039. 

  10039.         $s_buf = "";

    10040. 

  10040.         for ($ii = 0 ; $ii < $n_lines ; $ii++)

    10041. 

  10041.         {

    10042. 

  10042.             $s_buf .= $a_lines[$ii]."\n";

    10043. 

  10043.             unset($a_lines[$ii]);       // free memory (hopefully)

    10044. 

  10044.         }

    10045. 

  10045.         unset($a_lines);       // free memory (hopefully)

    10046. 

  10046. 

    10047. 

  10047.         if (IsSetSession("FormKeep"))

    10048. 

  10048.                 //

    10049. 

  10049.                 // put in any values that are being forward-remembered

    10050. 

  10050.                 //

    10051. 

  10051.             echo SetPreviousValues($s_buf,GetSession("FormKeep"));

    10052. 

  10052.         else

    10053. 

  10053.             echo $s_buf;

    10054. 

  10054.     }

    10055. 

  10055. }

    10056. 

  10056. 

    10057. 

  10057.     //

    10058. 

  10058.     // Insert a preamble into a MIME message.

    10059. 

  10059.     //

    10060. 

  10060. function MimePreamble(&$a_lines,$a_mesg = array())

    10061. 

  10061. {

    10062. 

  10062.     $a_preamble = explode("\n",GetMessage(MSG_MIME_PREAMBLE));

    10063. 

  10063.     foreach ($a_preamble as $s_line)

    10064. 

  10064.         $a_lines[] = $s_line.HEAD_CRLF;

    10065. 

  10065. 

    10066. 

  10066.     $a_lines[] = HEAD_CRLF;     // blank line

    10067. 

  10067.     $b_need_blank = false;

    10068. 

  10068.     foreach ($a_mesg as $s_line)

    10069. 

  10069.     {

    10070. 

  10070.         $a_lines[] = $s_line.HEAD_CRLF;

    10071. 

  10071.         if (!empty($s_line))

    10072. 

  10072.             $b_need_blank = true;

    10073. 

  10073.     }

    10074. 

  10074.     if ($b_need_blank)

    10075. 

  10075.         $a_lines[] = HEAD_CRLF;     // blank line

    10076. 

  10076. }

    10077. 

  10077. 

    10078. 

  10078.     //

    10079. 

  10079.     // Create the HTML mail

    10080. 

  10080.     //

    10081. 

  10081. function HTMLMail(&$a_lines,&$a_headers,$s_body,$s_template,$s_missing,$s_filter,

    10082. 

  10082.                             $s_boundary,$a_raw_fields,$b_no_plain,$b_process_template)

    10083. 

  10083. {

    10084. 

  10084.     $s_charset = GetMailOption("CharSet");

    10085. 

  10085.     if (!isset($s_charset))

    10086. 

  10086.         $s_charset = "ISO-8859-1";

    10087. 

  10087.     if ($b_no_plain)

    10088. 

  10088.     {

    10089. 

  10089.         $b_multi = false;

    10090. 

  10090.             //

    10091. 

  10091.             // don't provide a plain text version - just the HTML

    10092. 

  10092.             //

    10093. 

  10093.         $a_headers['Content-Type'] = SafeHeader("text/html; charset=$s_charset");

    10094. 

  10094.     }

    10095. 

  10095.     else

    10096. 

  10096.     {

    10097. 

  10097.         $b_multi = true;

    10098. 

  10098.         $a_headers['Content-Type'] = "multipart/alternative; boundary=\"$s_boundary\"";

    10099. 

  10099. 

    10100. 

  10100.         $a_pre_lines = explode("\n",GetMessage(MSG_MIME_HTML,

    10101. 

  10101.                                                 array("NAME"=>$s_template)));

    10102. 

  10102. 

    10103. 

  10103.         MimePreamble($a_lines,$a_pre_lines);

    10104. 

  10104. 

    10105. 

  10105.             //

    10106. 

  10106.             // first part - the text version only

    10107. 

  10107.             //

    10108. 

  10108.         $a_lines[] = "--$s_boundary".HEAD_CRLF;

    10109. 

  10109.         $a_lines[] = "Content-Type: text/plain; charset=$s_charset".HEAD_CRLF;

    10110. 

  10110.         $a_lines[] = HEAD_CRLF;     // blank line

    10111. 

  10111.             //

    10112. 

  10112.             // treat the body like one line, even though it isn't

    10113. 

  10113.             //

    10114. 

  10114.         $a_lines[] = $s_body;

    10115. 

  10115.         $a_lines[] = HEAD_CRLF;     // blank line

    10116. 

  10116.             //

    10117. 

  10117.             // second part - the HTML version

    10118. 

  10118.             //

    10119. 

  10119.         $a_lines[] = "--$s_boundary".HEAD_CRLF;

    10120. 

  10120.         $a_lines[] = "Content-Type: text/html; charset=$s_charset".HEAD_CRLF;

    10121. 

  10121.         $a_lines[] = HEAD_CRLF;     // blank line

    10122. 

  10122.     }

    10123. 

  10123. 

    10124. 

  10124.     $a_html_lines = array();

    10125. 

  10125.     if (!$b_process_template)

    10126. 

  10126.     {

    10127. 

  10127.         if (!ProcessTemplate($s_template,$a_html_lines,$a_raw_fields,NULL,'SubstituteValueDummy'))

    10128. 

  10128.             return (false);

    10129. 

  10129.     }

    10130. 

  10130.     elseif (!ProcessTemplate($s_template,$a_html_lines,$a_raw_fields,$s_missing))

    10131. 

  10131.         return (false);

    10132. 

  10132. 

    10133. 

  10133.     if (!empty($s_filter))

    10134. 

  10134.             //

    10135. 

  10135.             // treat the data like one line, even though it isn't

    10136. 

  10136.             //

    10137. 

  10137.         $a_lines[] = Filter($s_filter,$a_html_lines);

    10138. 

  10138.     else

    10139. 

  10139.         foreach ($a_html_lines as $s_line)

    10140. 

  10140.             $a_lines[] = $s_line;

    10141. 

  10141. 

    10142. 

  10142.     if ($b_multi)

    10143. 

  10143.     {

    10144. 

  10144.             //

    10145. 

  10145.             // end

    10146. 

  10146.             //

    10147. 

  10147.         $a_lines[] = "--$s_boundary--".HEAD_CRLF;

    10148. 

  10148.         $a_lines[] = HEAD_CRLF;     // blank line

    10149. 

  10149.     }

    10150. 

  10150.     return (true);

    10151. 

  10151. }

    10152. 

  10152. 

    10153. 

  10153.     //

    10154. 

  10154.     // Add the contents of a file in base64 encoding.

    10155. 

  10155.     //

    10156. 

  10156. function AddFile(&$a_lines,$s_file_name,$i_file_size,$b_remove = true)

    10157. 

  10157. {

    10158. 

  10158.     global  $php_errormsg;

    10159. 

  10159. 

    10160. 

  10160. @   $fp = fopen($s_file_name,"rb");

    10161. 

  10161.     if ($fp === false)

    10162. 

  10162.     {

    10163. 

  10163.         SendAlert(GetMessage(MSG_FILE_OPEN_ERROR,array("NAME"=>$s_file_name,

    10164. 

  10164.                                             "TYPE"=>"attachment",

    10165. 

  10165.                                             "ERROR"=>CheckString($php_errormsg))));

    10166. 

  10166.         return (false);

    10167. 

  10167.     }

    10168. 

  10168.         //

    10169. 

  10169.         // PHP under IIS has problems with the filesize function when

    10170. 

  10170.         // the file is on another drive.  So, we replaced a call

    10171. 

  10171.         // to filesize with the $i_file_size parameter (this occurred

    10172. 

  10172.         // in version 3.01).

    10173. 

  10173.         //

    10174. 

  10174.     $s_contents = fread($fp,$i_file_size);

    10175. 

  10175.         //

    10176. 

  10176.         // treat as a single line, even though it isn't

    10177. 

  10177.         //

    10178. 

  10178.     $a_lines[] = chunk_split(base64_encode($s_contents));

    10179. 

  10179.     fclose($fp);

    10180. 

  10180.     if ($b_remove)

    10181. 

  10181.         @unlink($s_file_name);

    10182. 

  10182.     return (true);

    10183. 

  10183. }

    10184. 

  10184. 

    10185. 

  10185.     //

    10186. 

  10186.     // Add the contents of a string in base64 encoding.

    10187. 

  10187.     //

    10188. 

  10188. function AddData(&$a_lines,$s_data)

    10189. 

  10189. {

    10190. 

  10190.         //

    10191. 

  10191.         // treat as a single line, even though it isn't

    10192. 

  10192.         //

    10193. 

  10193.     $a_lines[] = chunk_split(base64_encode($s_data));

    10194. 

  10194.     return (true);

    10195. 

  10195. }

    10196. 

  10196.     //

    10197. 

  10197.     // Check if a file is a valid uploaded file.

    10198. 

  10198.     //

    10199. 

  10199. function IsUploadedFile($a_file_spec)

    10200. 

  10200. {

    10201. 

  10201.         //

    10202. 

  10202.         // $a_file_spec["moved"] is our own internal flag to say we've

    10203. 

  10203.         // saved the file

    10204. 

  10204.         //

    10205. 

  10205.     if (isset($a_file_spec["moved"]) && $a_file_spec["moved"])

    10206. 

  10206.         return (true);

    10207. 

  10207.     return (is_uploaded_file($a_file_spec["tmp_name"]));

    10208. 

  10208. }

    10209. 

  10209. 

    10210. 

  10210.     //

    10211. 

  10211.     // Save an uploaded file to the repository directory.

    10212. 

  10212.     //

    10213. 

  10213. function SaveFileInRepository(&$a_file_spec)

    10214. 

  10214. {

    10215. 

  10215.     global  $php_errormsg,$FILE_REPOSITORY;

    10216. 

  10216. 

    10217. 

  10217.         //

    10218. 

  10218.         // if a replacement name has been specified, use that, otherwise

    10219. 

  10219.         // use the original name

    10220. 

  10220.         //

    10221. 

  10221.     if (isset($a_file_spec["new_name"]))

    10222. 

  10222.         $s_file_name = basename($a_file_spec["new_name"]);

    10223. 

  10223.     else

    10224. 

  10224.         $s_file_name = basename($a_file_spec["name"]);

    10225. 

  10225.     $s_dest = $FILE_REPOSITORY."/".$s_file_name;

    10226. 

  10226. 

    10227. 

  10227.     $b_ok = true;

    10228. 

  10228.     $s_error = "";

    10229. 

  10229. 

    10230. 

  10230.     if (isset($a_file_spec["saved_as"]) && !empty($a_file_spec["saved_as"]))

    10231. 

  10231.     {

    10232. 

  10232.         FMDebug("SaveFileInRepository: saved_as");

    10233. 

  10233.         $s_srce = $a_file_spec["saved_as"];

    10234. 

  10234.     }

    10235. 

  10235.     else

    10236. 

  10236.         $s_srce = $a_file_spec["tmp_name"];

    10237. 

  10237. 

    10238. 

  10238.     FMDebug("SaveFileInRepository: $s_srce");

    10239. 

  10239.     if (!FILE_OVERWRITE)

    10240. 

  10240.     {

    10241. 

  10241.         clearstatcache();

    10242. 

  10242.         if (@file_exists($s_dest))

    10243. 

  10243.         {

    10244. 

  10244.             $b_ok = false;

    10245. 

  10245.             $s_error = GetMessage(MSG_SAVE_FILE_EXISTS,array("FILE"=>$s_dest));

    10246. 

  10246.         }

    10247. 

  10247.     }

    10248. 

  10248.     if (MAX_FILE_UPLOAD_SIZE != 0 &&

    10249. 

  10249.         $a_file_spec["size"] > MAX_FILE_UPLOAD_SIZE*1024)

    10250. 

  10250.             //

    10251. 

  10251.             // this exits

    10252. 

  10252.             //

    10253. 

  10253.         UserError("upload_size",GetMessage(MSG_FILE_UPLOAD_SIZE,

    10254. 

  10254.                                   array("NAME"=>$a_file_spec["name"],

    10255. 

  10255.                                         "SIZE"=>$a_file_spec["size"],

    10256. 

  10256.                                         "MAX"=>MAX_FILE_UPLOAD_SIZE)));

    10257. 

  10257.     if ($b_ok)

    10258. 

  10258.     {

    10259. 

  10259.         if (isset($a_file_spec["saved_as"]) && !empty($a_file_spec["saved_as"]))

    10260. 

  10260.         {

    10261. 

  10261.             if (!copy($s_srce,$s_dest) || !@unlink($s_srce))

    10262. 

  10262.                 $b_ok = false;

    10263. 

  10263.         }

    10264. 

  10264.         else

    10265. 

  10265.         {

    10266. 

  10266.             if (!move_uploaded_file($s_srce,$s_dest))

    10267. 

  10267.                 $b_ok = false;

    10268. 

  10268.         }

    10269. 

  10269.         if ($b_ok)

    10270. 

  10270.         {

    10271. 

  10271.                 //

    10272. 

  10272.                 // Flag to say it's been put in the repository.

    10273. 

  10273.                 //

    10274. 

  10274.             $a_file_spec["in_repository"] = true;

    10275. 

  10275.                 //

    10276. 

  10276.                 // Its new location

    10277. 

  10277.                 //

    10278. 

  10278.             $a_file_spec["saved_as"] = $s_dest;

    10279. 

  10279.                 //

    10280. 

  10280.                 // Now that the file has been saved, "is_uploaded_file"

    10281. 

  10281.                 // will return false.  So, we create a flag to say it was

    10282. 

  10282.                 // valid.

    10283. 

  10283.                 //

    10284. 

  10284.             $a_file_spec["moved"] = true;

    10285. 

  10285.         }

    10286. 

  10286.         else

    10287. 

  10287.             $s_error = $php_errormsg;

    10288. 

  10288.     }

    10289. 

  10289.     if (!$b_ok)

    10290. 

  10290.     {

    10291. 

  10291.         SendAlert(GetMessage(MSG_SAVE_FILE,array(

    10292. 

  10292.                             "FILE"=>$s_srce,

    10293. 

  10293.                             "DEST"=>$s_dest,

    10294. 

  10294.                             "ERR"=>$s_error)));

    10295. 

  10295.         return (false);

    10296. 

  10296.     }

    10297. 

  10297.         //

    10298. 

  10298.         // ignore chmod fails (other than reporting them)

    10299. 

  10299.         //

    10300. 

  10300.     if (FILE_MODE != 0 && !chmod($s_dest,FILE_MODE))

    10301. 

  10301.         SendAlert(GetMessage(MSG_CHMOD,array(

    10302. 

  10302.                             "FILE"=>$s_dest,

    10303. 

  10303.                             "MODE"=>FILE_MODE,

    10304. 

  10304.                             "ERR"=>$s_error)));

    10305. 

  10305.     return (true);

    10306. 

  10306. }

    10307. 

  10307. 

    10308. 

  10308.     //

    10309. 

  10309.     // Save all uploaded files to the repository directory.

    10310. 

  10310.     //

    10311. 

  10311. function SaveAllFilesToRepository()

    10312. 

  10312. {

    10313. 

  10313.     global  $aFileVars,$FILE_REPOSITORY;

    10314. 

  10314. 

    10315. 

  10315.     if (!FILEUPLOADS || $FILE_REPOSITORY === "")

    10316. 

  10316.             //

    10317. 

  10317.             // nothing to do

    10318. 

  10318.             //

    10319. 

  10319.         return (true);

    10320. 

  10320. 

    10321. 

  10321.     foreach ($aFileVars as $m_file_key=>$a_upload)

    10322. 

  10322.     {

    10323. 

  10323.             //

    10324. 

  10324.             // One customer reported:

    10325. 

  10325.             //  Possible file upload attack detected: name='' temp name='none'

    10326. 

  10326.             // on PHP 4.1.2 on RAQ4.

    10327. 

  10327.             // So, we now also test for "name".

    10328. 

  10328.             //

    10329. 

  10329.         if (!isset($a_upload["tmp_name"]) || empty($a_upload["tmp_name"]) ||

    10330. 

  10330.             !isset($a_upload["name"]) || empty($a_upload["name"]))

    10331. 

  10331.             continue;

    10332. 

  10332.         if (isset($a_upload["in_repository"]) && $a_upload["in_repository"])

    10333. 

  10333.                 //

    10334. 

  10334.                 // already saved

    10335. 

  10335.                 //

    10336. 

  10336.             continue;

    10337. 

  10337.         if (!IsUploadedFile($a_upload))

    10338. 

  10338.         {

    10339. 

  10339.             SendAlert(GetMessage(MSG_FILE_UPLOAD_ATTACK,

    10340. 

  10340.                             array("NAME"=>$a_upload["name"],

    10341. 

  10341.                                     "TEMP"=>$a_upload["tmp_name"],

    10342. 

  10342.                                     "FLD"=>$m_file_key)));

    10343. 

  10343.             continue;

    10344. 

  10344.         }

    10345. 

  10345.         if (!SaveFileInRepository($aFileVars[$m_file_key]))

    10346. 

  10346.             return (false);

    10347. 

  10347.             //

    10348. 

  10348.             // Now the file has been saved in the repository, make

    10349. 

  10349.             // the field persistent through all further processing

    10350. 

  10350.             // (e.g. all movements in a multi-page form)

    10351. 

  10351.             //

    10352. 

  10352.         if (IsSetSession("FormSavedFiles"))

    10353. 

  10353.             $a_saved_files = GetSession("FormSavedFiles");

    10354. 

  10354.         else

    10355. 

  10355.             $a_saved_files = array();

    10356. 

  10356.         $a_saved_files["repository_".$m_file_key] = $aFileVars[$m_file_key];

    10357. 

  10357.         SetSession("FormSavedFiles",$a_saved_files);

    10358. 

  10358.     }

    10359. 

  10359.     return (true);

    10360. 

  10360. }

    10361. 

  10361. 

    10362. 

  10362.     //

    10363. 

  10363.     // Delete an uploaded file from the repository directory.

    10364. 

  10364.     // For security reasons, only the field name can be used.  This

    10365. 

  10365.     // uniquely identifies an uploaded file by this form process.

    10366. 

  10366.     //

    10367. 

  10367. function DeleteFileFromRepository($s_fld)

    10368. 

  10368. {

    10369. 

  10369.     global  $aFileVars,$FILE_REPOSITORY;

    10370. 

  10370. 

    10371. 

  10371.     if (!FILEUPLOADS || $FILE_REPOSITORY === "")

    10372. 

  10372.             //

    10373. 

  10373.             // nothing to do

    10374. 

  10374.             //

    10375. 

  10375.         return (false);

    10376. 

  10376. 

    10377. 

  10377.     if (($a_upload = GetFileInfo($s_fld)) === false)

    10378. 

  10378.         return (false);

    10379. 

  10379. 

    10380. 

  10380.     if (isset($a_upload["in_repository"]) && $a_upload["in_repository"])

    10381. 

  10381.     {

    10382. 

  10382.         if (isset($a_upload["saved_as"]) && !empty($a_upload["saved_as"]))

    10383. 

  10383.             @unlink($a_upload["saved_as"]);

    10384. 

  10384.     }

    10385. 

  10385.     DeleteFileInfo($s_fld);

    10386. 

  10386.     return (true);

    10387. 

  10387. }

    10388. 

  10388. 

    10389. 

  10389.     //

    10390. 

  10390.     // Save an uploaded file for later processing.

    10391. 

  10391.     //

    10392. 

  10392. function SaveUploadedFile(&$a_file_spec,$s_prefix)

    10393. 

  10393. {

    10394. 

  10394.     global  $php_errormsg;

    10395. 

  10395. 

    10396. 

  10396.     FMDebug("SaveUploadedFile");

    10397. 

  10397.     $s_dest = GetScratchPadFile($s_prefix);

    10398. 

  10398.     if (!move_uploaded_file($a_file_spec["tmp_name"],$s_dest))

    10399. 

  10399.     {

    10400. 

  10400.         SendAlert(GetMessage(MSG_SAVE_FILE,array(

    10401. 

  10401.                             "FILE"=>$a_file_spec["tmp_name"],

    10402. 

  10402.                             "DEST"=>$s_dest,

    10403. 

  10403.                             "ERR"=>$php_errormsg)));

    10404. 

  10404.         return (false);

    10405. 

  10405.     }

    10406. 

  10406.     $a_file_spec["saved_as"] = $s_dest;

    10407. 

  10407.     $a_file_spec["moved"] = true;

    10408. 

  10408.     return (true);

    10409. 

  10409. }

    10410. 

  10410. 

    10411. 

  10411.     //

    10412. 

  10412.     // Remove old files from the scratchpad directory.

    10413. 

  10413.     //

    10414. 

  10414. function CleanScratchPad($s_prefix = "")

    10415. 

  10415. {

    10416. 

  10416.     global  $lNow,$CLEANUP_TIME,$CLEANUP_CHANCE;

    10417. 

  10417.     global  $php_errormsg,$SCRATCH_PAD;

    10418. 

  10418. 

    10419. 

  10419.     if (!isset($SCRATCH_PAD) || empty($SCRATCH_PAD))

    10420. 

  10420.             //

    10421. 

  10421.             // no scratchpad to cleanup!

    10422. 

  10422.             //

    10423. 

  10423.         return;

    10424. 

  10424.     if ($CLEANUP_TIME <= 0)

    10425. 

  10425.             //

    10426. 

  10426.             // cleanup disabled

    10427. 

  10427.             //

    10428. 

  10428.         return;

    10429. 

  10429.         //

    10430. 

  10430.         // compute chance of cleanup

    10431. 

  10431.         //

    10432. 

  10432.     if ($CLEANUP_CHANCE < 100)

    10433. 

  10433.     {

    10434. 

  10434.         $i_rand = mt_rand(1,100);

    10435. 

  10435.         if ($i_rand > $CLEANUP_CHANCE)

    10436. 

  10436.             return;

    10437. 

  10437.     }

    10438. 

  10438.     if (($f_dir = @opendir($SCRATCH_PAD)) === false)

    10439. 

  10439.     {

    10440. 

  10440.         Error("open_scratch_pad",GetMessage(MSG_OPEN_SCRATCH_PAD,array(

    10441. 

  10441.                                         "DIR"=>$SCRATCH_PAD,

    10442. 

  10442.                                         "ERR"=>$php_errormsg)),false,false);

    10443. 

  10443.         return;

    10444. 

  10444.     }

    10445. 

  10445.     $i_len = strlen($s_prefix);

    10446. 

  10446.     while (($s_file = readdir($f_dir)) !== false)

    10447. 

  10447.     {

    10448. 

  10448.         $s_path = $SCRATCH_PAD."/".$s_file;

    10449. 

  10449.         if (is_file($s_path) && ($i_len == 0 || substr($s_file,0,$i_len) == $s_prefix))

    10450. 

  10450.         {

    10451. 

  10451.             if (($a_stat = @stat($s_path)) !== false)

    10452. 

  10452.             {

    10453. 

  10453.                 if (isset($a_stat['mtime']))

    10454. 

  10454.                     $l_time = $a_stat['mtime'];

    10455. 

  10455.                 else

    10456. 

  10456.                     $l_time = $a_stat[9];

    10457. 

  10457.                 if (($lNow - $l_time) / 60 >= $CLEANUP_TIME)

    10458. 

  10458.                     @unlink($s_path);

    10459. 

  10459.             }

    10460. 

  10460.         }

    10461. 

  10461.     }

    10462. 

  10462.     closedir($f_dir);

    10463. 

  10463. }

    10464. 

  10464. 

    10465. 

  10465.     //

    10466. 

  10466.     // Save all uploaded files for later processing.

    10467. 

  10467.     //

    10468. 

  10468. function SaveAllUploadedFiles(&$a_file_vars)

    10469. 

  10469. {

    10470. 

  10470.     global  $php_errormsg,$SCRATCH_PAD;

    10471. 

  10471. 

    10472. 

  10472.     $s_prefix = "UPLD";

    10473. 

  10473.     if (!isset($SCRATCH_PAD) || empty($SCRATCH_PAD))

    10474. 

  10474.     {

    10475. 

  10475.         Error("need_scratch_pad",GetMessage(MSG_NEED_SCRATCH_PAD),false,false);

    10476. 

  10476.         return (false);

    10477. 

  10477.     }

    10478. 

  10478. 

    10479. 

  10479.         //

    10480. 

  10480.         // remove old uploaded files that have not been moved out.

    10481. 

  10481.         //

    10482. 

  10482.     CleanScratchPad($s_prefix);

    10483. 

  10483. 

    10484. 

  10484.     foreach (array_keys($a_file_vars) as $m_file_key)

    10485. 

  10485.     {

    10486. 

  10486.         $a_upload = &$a_file_vars[$m_file_key];

    10487. 

  10487.             //

    10488. 

  10488.             // One customer reported:

    10489. 

  10489.             //  Possible file upload attack detected: name='' temp name='none'

    10490. 

  10490.             // on PHP 4.1.2 on RAQ4.

    10491. 

  10491.             // So, we now also test for "name".

    10492. 

  10492.             //

    10493. 

  10493.         if (!isset($a_upload["tmp_name"]) || empty($a_upload["tmp_name"]) ||

    10494. 

  10494.             !isset($a_upload["name"]) || empty($a_upload["name"]))

    10495. 

  10495.             continue;

    10496. 

  10496.             //

    10497. 

  10497.             // ensure we don't move the file more than once

    10498. 

  10498.             //

    10499. 

  10499.         if (!isset($a_upload["saved_as"]) || empty($a_upload["saved_as"]))

    10500. 

  10500.             if (!IsUploadedFile($a_upload))

    10501. 

  10501.                 SendAlert(GetMessage(MSG_FILE_UPLOAD_ATTACK,

    10502. 

  10502.                                 array("NAME"=>$a_upload["name"],

    10503. 

  10503.                                         "TEMP"=>$a_upload["tmp_name"],

    10504. 

  10504.                                         "FLD"=>$m_file_key)));

    10505. 

  10505.             elseif (!SaveUploadedFile($a_upload,$s_prefix))

    10506. 

  10506.                 return (false);

    10507. 

  10507.     }

    10508. 

  10508.     return (true);

    10509. 

  10509. }

    10510. 

  10510. 

    10511. 

  10511.     //

    10512. 

  10512.     // Attach a file to the body of a MIME formatted email.  $a_lines is the

    10513. 

  10513.     // current body, and is modified to include the file.

    10514. 

  10514.     // $a_file_spec must have the following values (just like an uploaded

    10515. 

  10515.     // file specification):

    10516. 

  10516.     //      name        the name of the file

    10517. 

  10517.     //      type        the mime type

    10518. 

  10518.     //      tmp_name    the name of the temporary file

    10519. 

  10519.     //      size        the size of the temporary file

    10520. 

  10520.     //

    10521. 

  10521.     // Alternatively, you supply the following instead of tmp_name and size:

    10522. 

  10522.     //      data        the data to attach

    10523. 

  10523.     //

    10524. 

  10524. function AttachFile(&$a_lines,$s_att_boundary,$a_file_spec,$s_charset,$b_remove = true)

    10525. 

  10525. {

    10526. 

  10526.     $a_lines[] = "--$s_att_boundary".HEAD_CRLF;

    10527. 

  10527.         //

    10528. 

  10528.         // if a replacement name has been specified, use that, otherwise

    10529. 

  10529.         // use the original name

    10530. 

  10530.         //

    10531. 

  10531.     if (isset($a_file_spec["new_name"]))

    10532. 

  10532.         $s_file_name = $a_file_spec["new_name"];

    10533. 

  10533.     else

    10534. 

  10534.         $s_file_name = $a_file_spec["name"];

    10535. 

  10535.     $s_file_name = str_replace('"','',$s_file_name);

    10536. 

  10536.     $s_mime_type = $a_file_spec["type"];

    10537. 

  10537.             //

    10538. 

  10538.             // The following says that the data is encoded in

    10539. 

  10539.             // base64 and is an attachment and that once decoded the

    10540. 

  10540.             // character set of the decoded data is $s_charset.

    10541. 

  10541.             // (See RFC 1521 Section 5.)

    10542. 

  10542.             //

    10543. 

  10543.     $a_lines[] = "Content-Type: $s_mime_type; name=\"$s_file_name\"; charset=$s_charset".HEAD_CRLF;

    10544. 

  10544.     $a_lines[] = "Content-Transfer-Encoding: base64".HEAD_CRLF;

    10545. 

  10545.     $a_lines[] = "Content-Disposition: attachment; filename=\"$s_file_name\"".HEAD_CRLF;

    10546. 

  10546.     $a_lines[] = HEAD_CRLF;         // blank line

    10547. 

  10547.     if (isset($a_file_spec["tmp_name"]) && isset($a_file_spec["size"]))

    10548. 

  10548.     {

    10549. 

  10549.         $s_srce = $a_file_spec["tmp_name"];

    10550. 

  10550.             //

    10551. 

  10551.             // check if the file has been saved elsewhere

    10552. 

  10552.             //

    10553. 

  10553.         if (isset($a_file_spec["saved_as"]) && !empty($a_file_spec["saved_as"]))

    10554. 

  10554.             $s_srce = $a_file_spec["saved_as"];

    10555. 

  10555.         FMDebug("AttachFile: $s_srce");

    10556. 

  10556.         return (AddFile($a_lines,$s_srce,$a_file_spec["size"],$b_remove));

    10557. 

  10557.     }

    10558. 

  10558.     if (!isset($a_file_spec["data"]))

    10559. 

  10559.     {

    10560. 

  10560.         SendAlert(GetMessage(MSG_ATTACH_DATA));

    10561. 

  10561.         return (false);

    10562. 

  10562.     }

    10563. 

  10563.     return (AddData($a_lines,$a_file_spec["data"]));

    10564. 

  10564. }

    10565. 

  10565. 

    10566. 

  10566.     //

    10567. 

  10567.     // Reformat the email to be in MIME format.

    10568. 

  10568.     // Process file attachments and and fill out any

    10569. 

  10569.     // specified HTML template.

    10570. 

  10570.     //

    10571. 

  10571. function MakeMimeMail(&$s_body,&$a_headers,$a_raw_fields,$s_template = "",

    10572. 

  10572.                     $s_missing = NULL,$b_no_plain = false,

    10573. 

  10573.                     $s_filter = "",$a_file_vars = array(),

    10574. 

  10574.                     $a_attach_spec = array(),$b_process_template = true)

    10575. 

  10575. {

    10576. 

  10576.     global  $FM_VERS,$aPHPVERSION;

    10577. 

  10577.     global  $SPECIAL_VALUES,$FILE_REPOSITORY;

    10578. 

  10578. 

    10579. 

  10579.     $s_charset = GetMailOption("CharSet");

    10580. 

  10580.     if (!isset($s_charset))

    10581. 

  10581.         $s_charset = "ISO-8859-1";

    10582. 

  10582.     $b_att = $b_html = false;

    10583. 

  10583.     $b_got_filter = (isset($s_filter) && !empty($s_filter));

    10584. 

  10584.     if (isset($s_template) && !empty($s_template))

    10585. 

  10585.     {

    10586. 

  10586.             //

    10587. 

  10587.             // need PHP 4.0.5 for the preg_replace_callback function

    10588. 

  10588.             //

    10589. 

  10589.         if (!IsPHPAtLeast("4.0.5"))

    10590. 

  10590.         {

    10591. 

  10591.             SendAlert(GetMessage(MSG_PHP_HTML_TEMPLATES,

    10592. 

  10592.                             array("PHPVERS"=>implode(".",$aPHPVERSION))));

    10593. 

  10593.             return (false);

    10594. 

  10594.         }

    10595. 

  10595.         $b_html = true;

    10596. 

  10596.     }

    10597. 

  10597.     if (count($a_file_vars) > 0)

    10598. 

  10598.     {

    10599. 

  10599.         if (!IsPHPAtLeast("4.0.3"))

    10600. 

  10600.         {

    10601. 

  10601.             SendAlert(GetMessage(MSG_PHP_FILE_UPLOADS,

    10602. 

  10602.                             array("PHPVERS"=>implode(".",$aPHPVERSION))));

    10603. 

  10603.             return (false);

    10604. 

  10604.         }

    10605. 

  10605.         if (!FILEUPLOADS)

    10606. 

  10606.             SendAlert(GetMessage(MSG_FILE_UPLOAD));

    10607. 

  10607.             //

    10608. 

  10608.             // if storing files in the server repository, don't attach

    10609. 

  10609.             // unless the mail_options insist

    10610. 

  10610.             //

    10611. 

  10611.         elseif ($FILE_REPOSITORY === "" || IsMailOptionSet("AlwaysEmailFiles"))

    10612. 

  10612.             foreach ($a_file_vars as $a_upload)

    10613. 

  10613.             {

    10614. 

  10614.                     //

    10615. 

  10615.                     // One customer reported:

    10616. 

  10616.                     //  Possible file upload attack detected: name='' temp name='none'

    10617. 

  10617.                     // on PHP 4.1.2 on RAQ4.

    10618. 

  10618.                     // So, we now also test for "name".

    10619. 

  10619.                     //

    10620. 

  10620.                 if (isset($a_upload["tmp_name"]) && !empty($a_upload["tmp_name"]) &&

    10621. 

  10621.                     isset($a_upload["name"]) && !empty($a_upload["name"]))

    10622. 

  10622.                 {

    10623. 

  10623.                     $b_att = true;

    10624. 

  10624.                     break;

    10625. 

  10625.                 }

    10626. 

  10626.             }

    10627. 

  10627.     }

    10628. 

  10628.         //

    10629. 

  10629.         // check for an internally-generated attachment

    10630. 

  10630.         //

    10631. 

  10631.     if (isset($a_attach_spec["Data"]))

    10632. 

  10632.         $b_att = true;

    10633. 

  10633. 

    10634. 

  10634.     $s_uniq = md5($s_body);

    10635. 

  10635.     $s_body_boundary = "BODY$s_uniq";

    10636. 

  10636.     $s_att_boundary = "PART$s_uniq";

    10637. 

  10637.     $a_headers['MIME-Version'] = "1.0 (produced by FormMail $FM_VERS from www.tectite.com)";

    10638. 

  10638. 

    10639. 

  10639.         //

    10640. 

  10640.         // if the filter strips formatting, then we'll only have plain text

    10641. 

  10641.         // to send, even after the template has been used

    10642. 

  10642.         //

    10643. 

  10643.     if ($b_got_filter && IsFilterAttribSet($s_filter,"Strips"))

    10644. 

  10644.             //

    10645. 

  10645.             // no HTML if the filter strips the formatting

    10646. 

  10646.             //

    10647. 

  10647.         $b_html = false;

    10648. 

  10648.     $a_new = array();

    10649. 

  10649.     if ($b_att)

    10650. 

  10650.     {

    10651. 

  10651.         $a_headers['Content-Type'] = "multipart/mixed; boundary=\"$s_att_boundary\"";

    10652. 

  10652. 

    10653. 

  10653.         MimePreamble($a_new);

    10654. 

  10654.             //

    10655. 

  10655.             // add the body of the email

    10656. 

  10656.             //

    10657. 

  10657.         $a_new[] = "--$s_att_boundary".HEAD_CRLF;

    10658. 

  10658.         if ($b_html)

    10659. 

  10659.         {

    10660. 

  10660.             $a_lines = $a_local_headers = array();

    10661. 

  10661.             if (!HTMLMail($a_lines,$a_local_headers,$s_body,$s_template,

    10662. 

  10662.                             $s_missing,($b_got_filter) ? $s_filter : "",

    10663. 

  10663.                             $s_body_boundary,$a_raw_fields,$b_no_plain,

    10664. 

  10664.                             $b_process_template))

    10665. 

  10665.                 return (false);

    10666. 

  10666.             $a_new = array_merge($a_new,ExpandMailHeadersArray($a_local_headers));

    10667. 

  10667.             $a_new[] = HEAD_CRLF;       // blank line after header

    10668. 

  10668.             $a_new = array_merge($a_new,$a_lines);

    10669. 

  10669.         }

    10670. 

  10670.         else

    10671. 

  10671.         {

    10672. 

  10672.             $a_new[] = "Content-Type: text/plain; charset=$s_charset".HEAD_CRLF;

    10673. 

  10673.             $a_new[] = HEAD_CRLF;       // blank line

    10674. 

  10674.                 //

    10675. 

  10675.                 // treat the body like one line, even though it isn't

    10676. 

  10676.                 //

    10677. 

  10677.             $a_new[] = $s_body;

    10678. 

  10678.         }

    10679. 

  10679.             //

    10680. 

  10680.             // now add the attachments or save to the $FILE_REPOSITORY

    10681. 

  10681.             //

    10682. 

  10682.         if (FILEUPLOADS && ($FILE_REPOSITORY === "" || IsMailOptionSet("AlwaysEmailFiles")))

    10683. 

  10683.             foreach ($a_file_vars as $m_file_key=>$a_upload)

    10684. 

  10684.             {

    10685. 

  10685.                     //

    10686. 

  10686.                     // One customer reported:

    10687. 

  10687.                     //  Possible file upload attack detected: name='' temp name='none'

    10688. 

  10688.                     // on PHP 4.1.2 on RAQ4.

    10689. 

  10689.                     // So, we now also test for "name".

    10690. 

  10690.                     //

    10691. 

  10691.                 if (!isset($a_upload["tmp_name"]) || empty($a_upload["tmp_name"]) ||

    10692. 

  10692.                     !isset($a_upload["name"]) || empty($a_upload["name"]))

    10693. 

  10693.                     continue;

    10694. 

  10694.                 if (!IsUploadedFile($a_upload))

    10695. 

  10695.                 {

    10696. 

  10696.                     SendAlert(GetMessage(MSG_FILE_UPLOAD_ATTACK,

    10697. 

  10697.                                     array("NAME"=>$a_upload["name"],

    10698. 

  10698.                                           "TEMP"=>$a_upload["tmp_name"],

    10699. 

  10699.                                           "FLD"=>$m_file_key)));

    10700. 

  10700.                     continue;

    10701. 

  10701.                 }

    10702. 

  10702.                 if (MAX_FILE_UPLOAD_SIZE != 0 &&

    10703. 

  10703.                     $a_upload["size"] > MAX_FILE_UPLOAD_SIZE*1024)

    10704. 

  10704.                     UserError("upload_size",GetMessage(MSG_FILE_UPLOAD_SIZE,

    10705. 

  10705.                                               array("NAME"=>$a_upload["name"],

    10706. 

  10706.                                                     "SIZE"=>$a_upload["size"],

    10707. 

  10707.                                                     "MAX"=>MAX_FILE_UPLOAD_SIZE)));

    10708. 

  10708.                 if (!AttachFile($a_new,$s_att_boundary,$a_upload,$s_charset,

    10709. 

  10709.                             ($FILE_REPOSITORY === "") ? true : false))

    10710. 

  10710.                     return (false);

    10711. 

  10711.             }

    10712. 

  10712.         if (isset($a_attach_spec["Data"]))

    10713. 

  10713.         {

    10714. 

  10714.                 //

    10715. 

  10715.                 // build a specification similar to a file upload

    10716. 

  10716.                 //

    10717. 

  10717.             $a_file_spec["name"] = isset($a_attach_spec["Name"]) ?

    10718. 

  10718.                                         $a_attach_spec["Name"] :

    10719. 

  10719.                                         "attachment.dat";

    10720. 

  10720.             $a_file_spec["type"] = isset($a_attach_spec["MIME"]) ?

    10721. 

  10721.                                         $a_attach_spec["MIME"] :

    10722. 

  10722.                                         "text/plain";

    10723. 

  10723.             $a_file_spec["data"] = $a_attach_spec["Data"];

    10724. 

  10724.             if (!AttachFile($a_new,$s_att_boundary,$a_file_spec,

    10725. 

  10725.                                 isset($a_attach_spec["CharSet"]) ?

    10726. 

  10726.                                 $a_attach_spec["CharSet"] :

    10727. 

  10727.                                 $s_charset))

    10728. 

  10728.                 return (false);

    10729. 

  10729.         }

    10730. 

  10730.         $a_new[] = "--$s_att_boundary--".HEAD_CRLF;     // the end

    10731. 

  10731.         $a_new[] = HEAD_CRLF;           // blank line

    10732. 

  10732.     }

    10733. 

  10733.     elseif ($b_html)

    10734. 

  10734.     {

    10735. 

  10735.         if (!HTMLMail($a_new,$a_headers,$s_body,$s_template,

    10736. 

  10736.                             $s_missing,($b_got_filter) ? $s_filter : "",

    10737. 

  10737.                             $s_body_boundary,$a_raw_fields,$b_no_plain,

    10738. 

  10738.                             $b_process_template))

    10739. 

  10739.             return (false);

    10740. 

  10740.     }

    10741. 

  10741.     else

    10742. 

  10742.     {

    10743. 

  10743.         $a_headers['Content-Type'] = SafeHeader("text/plain; charset=$s_charset");

    10744. 

  10744.             //

    10745. 

  10745.             // treat the body like one line, even though it isn't

    10746. 

  10746.             //

    10747. 

  10747.         $a_new[] = $s_body;

    10748. 

  10748.     }

    10749. 

  10749. 

    10750. 

  10750.     $s_body = JoinLines(BODY_LF,$a_new);

    10751. 

  10751.     return (true);

    10752. 

  10752. }

    10753. 

  10753. 

    10754. 

  10754.     //

    10755. 

  10755.     // to make a From line for the email

    10756. 

  10756.     //

    10757. 

  10757. function MakeFromLine($s_email,$s_name)

    10758. 

  10758. {

    10759. 

  10759.     $s_style = GetMailOption("FromLineStyle");

    10760. 

  10760.     $s_line = "";

    10761. 

  10761.     if (!isset($s_style))

    10762. 

  10762.         $s_style = "";

    10763. 

  10763.         //

    10764. 

  10764.         // the following From line styles are in accordance with RFC 822

    10765. 

  10765.         //

    10766. 

  10766.     switch ($s_style)

    10767. 

  10767.     {

    10768. 

  10768.     default:

    10769. 

  10769.     case "":

    10770. 

  10770.     case "default":

    10771. 

  10771.     case "AddrSpecName":

    10772. 

  10772.                 //

    10773. 

  10773.                 // this is the original From line style that FormMail produced

    10774. 

  10774.                 // e.g.

    10775. 

  10775.                 //      jack@nowhere.com (Jack Smith)

    10776. 

  10776.                 // this is an addr-spec with a trailing comment with the name

    10777. 

  10777.                 //

    10778. 

  10778.         if (!empty($s_email))

    10779. 

  10779.             $s_line .= SafeHeaderEmail($s_email)." ";

    10780. 

  10780.         if (!empty($s_name))

    10781. 

  10781.             $s_line .= "(".SafeHeaderComment(EncodeHeaderText($s_name)).")";

    10782. 

  10782.         break;

    10783. 

  10783.     case "NameAddrSpec":

    10784. 

  10784.                 //

    10785. 

  10785.                 // email address as an addr-spec preceded by a comment with the name

    10786. 

  10786.                 // e.g.

    10787. 

  10787.                 //      (Jack Smith) jack@nowhere.com

    10788. 

  10788.                 //

    10789. 

  10789.         if (!empty($s_name))

    10790. 

  10790.             $s_line .= "(".SafeHeaderComment(EncodeHeaderText($s_name)).") ";

    10791. 

  10791.         if (!empty($s_email))

    10792. 

  10792.             $s_line .= SafeHeaderEmail($s_email);

    10793. 

  10793.         break;

    10794. 

  10794.     case "RouteAddr":

    10795. 

  10795.                 //

    10796. 

  10796.                 // just the email address as a route-addr

    10797. 

  10797.                 // e.g.

    10798. 

  10798.                 //      <jack@nowhere.com>

    10799. 

  10799.                 //

    10800. 

  10800.         if (!empty($s_email))

    10801. 

  10801.             $s_line .= "<".SafeHeaderEmail($s_email).">";

    10802. 

  10802.         break;

    10803. 

  10803.     case "QuotedNameRouteAddr":

    10804. 

  10804.                 //

    10805. 

  10805.                 // email address as a route-addr preceded

    10806. 

  10806.                 // by the name of the user as a quoted string

    10807. 

  10807.                 // e.g.

    10808. 

  10808.                 //      "Jack Smith" <jack@nowhere.com>

    10809. 

  10809.                 //

    10810. 

  10810.         if (!empty($s_name))

    10811. 

  10811.             $s_line .= '"'.SafeHeaderQString(EncodeHeaderText($s_name)).'" ';

    10812. 

  10812.         if (!empty($s_email))

    10813. 

  10813.             $s_line .= "<".SafeHeaderEmail($s_email).">";

    10814. 

  10814.         break;

    10815. 

  10815.     case "NameRouteAddr":

    10816. 

  10816.                 //

    10817. 

  10817.                 // email address as a route-addr preceded

    10818. 

  10818.                 // by the name of the user as words

    10819. 

  10819.                 // e.g.

    10820. 

  10820.                 //      Jack Smith <jack@nowhere.com>

    10821. 

  10821.                 //

    10822. 

  10822.         if (!empty($s_name))

    10823. 

  10823.             $s_line .= SafeHeaderWords(EncodeHeaderText($s_name)).' ';

    10824. 

  10824.         if (!empty($s_email))

    10825. 

  10825.             $s_line .= "<".SafeHeaderEmail($s_email).">";

    10826. 

  10826.         break;

    10827. 

  10827.     }

    10828. 

  10828.     return ($s_line);

    10829. 

  10829. }

    10830. 

  10830. 

    10831. 

  10831.     //

    10832. 

  10832.     // Return two sets of plain text output: the filtered fields and the

    10833. 

  10833.     // non-filtered fields.

    10834. 

  10834.     //

    10835. 

  10835. function GetFilteredOutput($a_fld_order,$a_clean_fields,$s_filter,$a_filter_list)

    10836. 

  10836. {

    10837. 

  10837.         //

    10838. 

  10838.         // find the non-filtered fields and make unfiltered text from them

    10839. 

  10839.         //

    10840. 

  10840.     $a_unfiltered_list = array();

    10841. 

  10841.     $n_flds = count($a_fld_order);

    10842. 

  10842.     for ($ii = 0 ; $ii < $n_flds ; $ii++)

    10843. 

  10843.         if (!in_array($a_fld_order[$ii],$a_filter_list))

    10844. 

  10844.             $a_unfiltered_list[] = $a_fld_order[$ii];

    10845. 

  10845.     $s_unfiltered_results = MakeFieldOutput($a_unfiltered_list,$a_clean_fields);

    10846. 

  10846.         //

    10847. 

  10847.         // filter the specified fields only

    10848. 

  10848.         //

    10849. 

  10849.     $s_filtered_results = MakeFieldOutput($a_filter_list,$a_clean_fields);

    10850. 

  10850.     $s_filtered_results = Filter($s_filter,$s_filtered_results);

    10851. 

  10851.     return (array($s_unfiltered_results,$s_filtered_results));

    10852. 

  10852. }

    10853. 

  10853. 

    10854. 

  10854.     //

    10855. 

  10855.     // Make a plain text email body

    10856. 

  10856.     //

    10857. 

  10857. function MakePlainEmail($a_fld_order,$a_clean_fields,

    10858. 

  10858.                         $s_to,$s_cc,$s_bcc,$a_raw_fields,$s_filter,$a_filter_list)

    10859. 

  10859. {

    10860. 

  10860.     global  $SPECIAL_VALUES,$aPHPVERSION;

    10861. 

  10861. 

    10862. 

  10862.     $s_unfiltered_results = $s_filtered_results = "";

    10863. 

  10863.     $b_got_filter = (isset($s_filter) && !empty($s_filter));

    10864. 

  10864.     if ($b_got_filter)

    10865. 

  10865.         if (isset($a_filter_list) && count($a_filter_list) > 0)

    10866. 

  10866.             $b_limited_filter = true;

    10867. 

  10867.         else

    10868. 

  10868.             $b_limited_filter = false;

    10869. 

  10869.     $b_used_template = false;

    10870. 

  10870.     if (IsMailOptionSet("PlainTemplate"))

    10871. 

  10871.     {

    10872. 

  10872.             //

    10873. 

  10873.             // need PHP 4.0.5 for the preg_replace_callback function

    10874. 

  10874.             //

    10875. 

  10875.         if (!IsPHPAtLeast("4.0.5"))

    10876. 

  10876.             SendAlert(GetMessage(MSG_PHP_PLAIN_TEMPLATES,

    10877. 

  10877.                             array("PHPVERS"=>implode(".",$aPHPVERSION))));

    10878. 

  10878.         else

    10879. 

  10879.         {

    10880. 

  10880.             $s_template = GetMailOption("PlainTemplate");

    10881. 

  10881.             if (ProcessTemplate($s_template,$a_lines,$a_raw_fields,

    10882. 

  10882.                                 GetMailOption('TemplateMissing'),

    10883. 

  10883.                                 'SubstituteValuePlain'))

    10884. 

  10884.             {

    10885. 

  10885.                 $b_used_template = true;

    10886. 

  10886.                 $s_unfiltered_results = implode(BODY_LF,$a_lines);

    10887. 

  10887.                 if ($b_got_filter)

    10888. 

  10888.                 {

    10889. 

  10889.                         //

    10890. 

  10890.                         // with a limited filter, the template goes unfiltered

    10891. 

  10891.                         // and the named fields get filtered

    10892. 

  10892.                         //

    10893. 

  10893.                     if ($b_limited_filter)

    10894. 

  10894.                         list($s_discard,$s_filtered_results) =

    10895. 

  10895.                                     GetFilteredOutput($a_fld_order,$a_clean_fields,

    10896. 

  10896.                                             $s_filter,$a_filter_list);

    10897. 

  10897.                     else

    10898. 

  10898.                     {

    10899. 

  10899.                         $s_filtered_results = Filter($s_filter,$s_unfiltered_results);

    10900. 

  10900.                         $s_unfiltered_results = "";

    10901. 

  10901.                     }

    10902. 

  10902.                 }

    10903. 

  10903.             }

    10904. 

  10904.         }

    10905. 

  10905.     }

    10906. 

  10906.     if (!$b_used_template)

    10907. 

  10907.     {

    10908. 

  10908.         $res_hdr = "";

    10909. 

  10909. 

    10910. 

  10910.         if (IsMailOptionSet("DupHeader"))

    10911. 

  10911.         {

    10912. 

  10912.                 //

    10913. 

  10913.                 // write some standard mail headers

    10914. 

  10914.                 //

    10915. 

  10915.             $res_hdr = "To: $s_to".BODY_LF;

    10916. 

  10916.             if (!empty($s_cc))

    10917. 

  10917.                 $res_hdr .= "Cc: $s_cc".BODY_LF;

    10918. 

  10918.             if (!empty($SPECIAL_VALUES["email"]))

    10919. 

  10919.                 $res_hdr .= "From: ".MakeFromLine($SPECIAL_VALUES["email"],

    10920. 

  10920.                                         $SPECIAL_VALUES["realname"]).BODY_LF;

    10921. 

  10921.             $res_hdr .= BODY_LF;

    10922. 

  10922.             if (IsMailOptionSet("StartLine"))

    10923. 

  10923.                 $res_hdr .= "--START--".BODY_LF;        // signals the beginning of the text to filter

    10924. 

  10924.         }

    10925. 

  10925. 

    10926. 

  10926.             //

    10927. 

  10927.             // put the realname and the email address at the top of the results

    10928. 

  10928.             // (if not excluded)

    10929. 

  10929.             //

    10930. 

  10930.         if (!IsMailExcluded("realname"))

    10931. 

  10931.         {

    10932. 

  10932.             array_unshift($a_fld_order,"realname");

    10933. 

  10933.             $a_clean_fields["realname"] = $SPECIAL_VALUES["realname"];

    10934. 

  10934.         }

    10935. 

  10935.         if (!IsMailExcluded("email"))

    10936. 

  10936.         {

    10937. 

  10937.             array_unshift($a_fld_order,"email");

    10938. 

  10938.             $a_clean_fields["email"] = $SPECIAL_VALUES["email"];

    10939. 

  10939.         }

    10940. 

  10940.         if ($b_got_filter)

    10941. 

  10941.         {

    10942. 

  10942.             if ($b_limited_filter)

    10943. 

  10943.                 list($s_unfiltered_results,$s_filtered_results) =

    10944. 

  10944.                             GetFilteredOutput($a_fld_order,$a_clean_fields,

    10945. 

  10945.                                     $s_filter,$a_filter_list);

    10946. 

  10946.             else

    10947. 

  10947.             {

    10948. 

  10948.                     //

    10949. 

  10949.                     // make text output and filter it (filter all fields)

    10950. 

  10950.                     //

    10951. 

  10951.                 $s_filtered_results = MakeFieldOutput($a_fld_order,$a_clean_fields);

    10952. 

  10952.                 $s_filtered_results = Filter($s_filter,$s_filtered_results);

    10953. 

  10953.             }

    10954. 

  10954.         }

    10955. 

  10955.         else

    10956. 

  10956.         {

    10957. 

  10957. //SendAlert("There are ".count($a_fld_order)." fields in the order array");

    10958. 

  10958. //SendAlert("Here is the clean fields array:\r\n".var_export($a_clean_fields,true));

    10959. 

  10959.             $s_unfiltered_results = MakeFieldOutput($a_fld_order,$a_clean_fields);

    10960. 

  10960.         }

    10961. 

  10961.         $s_unfiltered_results = $res_hdr.$s_unfiltered_results;

    10962. 

  10962.     }

    10963. 

  10963.     $s_results = $s_unfiltered_results;

    10964. 

  10964.     if ($b_got_filter && !empty($s_filtered_results))

    10965. 

  10965.     {

    10966. 

  10966.         if (!empty($s_results))

    10967. 

  10967.             $s_results .= BODY_LF;

    10968. 

  10968.         $s_results .= $s_filtered_results;

    10969. 

  10969.     }

    10970. 

  10970.         //

    10971. 

  10971.         // append the environment variables report

    10972. 

  10972.         //

    10973. 

  10973.     if (isset($SPECIAL_VALUES["env_report"]) && !empty($SPECIAL_VALUES["env_report"]))

    10974. 

  10974.     {

    10975. 

  10975.         $s_results .= BODY_LF."==================================".BODY_LF;

    10976. 

  10976.         $s_results .= BODY_LF.GetEnvVars(TrimArray(explode(",",$SPECIAL_VALUES["env_report"])),BODY_LF);

    10977. 

  10977.     }

    10978. 

  10978.     return (array($s_results,$s_unfiltered_results,$s_filtered_results));

    10979. 

  10979. }

    10980. 

  10980. 

    10981. 

  10981.     //

    10982. 

  10982.     // Return the list of fields to be filtered, FALSE if no list provided.

    10983. 

  10983.     //

    10984. 

  10984. function GetFilterList($b_file_fields)

    10985. 

  10985. {

    10986. 

  10986.     global  $SPECIAL_VALUES;

    10987. 

  10987. 

    10988. 

  10988.         //

    10989. 

  10989.         // no filter means no list of fields

    10990. 

  10990.         //

    10991. 

  10991.     if (!empty($SPECIAL_VALUES["filter"]))

    10992. 

  10992.     {

    10993. 

  10993.         if ($b_file_fields)

    10994. 

  10994.         {

    10995. 

  10995.             if (isset($SPECIAL_VALUES["filter_files"]) && !empty($SPECIAL_VALUES["filter_files"]))

    10996. 

  10996.                 return (TrimArray(explode(",",$SPECIAL_VALUES["filter_files"])));

    10997. 

  10997.         }

    10998. 

  10998.         else

    10999. 

  10999.         {

    11000. 

  11000.             if (isset($SPECIAL_VALUES["filter_fields"]) && !empty($SPECIAL_VALUES["filter_fields"]))

    11001. 

  11001.                 return (TrimArray(explode(",",$SPECIAL_VALUES["filter_fields"])));

    11002. 

  11002.         }

    11003. 

  11003.     }

    11004. 

  11004.     return (false);

    11005. 

  11005. }

    11006. 

  11006. 

    11007. 

  11007. /* 

    11008. 

  11008.  * Function:    GetFilterSpec

    11009. 

  11009.  * Parameters:  $s_filter       returns the filter name

    11010. 

  11010.  *              $m_filter_list  returns the list of fields to filter (an array)

    11011. 

  11011.  *                              or is set to false if there is no filter list

    11012. 

  11012.  *              $b_file_fields  if true, return file fields, otherwise return non-file fields

    11013. 

  11013.  * Returns:     bool            true if filtering a list of fields of the specified type

    11014. 

  11014.  * Description:     

    11015. 

  11015.  *  Checks whether the form has specified to filter a list of 

    11016. 

  11016.  *  fields of the specified type (file fields or non-file fields).

    11017. 

  11017.  */

    11018. 

  11018. function    GetFilterSpec(&$s_filter,&$m_filter_list,$b_file_fields = false)

    11019. 

  11019. {

    11020. 

  11020.     global  $SPECIAL_VALUES;

    11021. 

  11021. 

    11022. 

  11022.     if (isset($SPECIAL_VALUES["filter"]) && !empty($SPECIAL_VALUES["filter"]))

    11023. 

  11023.     {

    11024. 

  11024.         $s_filter = $SPECIAL_VALUES["filter"];

    11025. 

  11025.         $m_filter_list = GetFilterList($b_file_fields);

    11026. 

  11026.         return (true);

    11027. 

  11027.     }

    11028. 

  11028.     return (false);

    11029. 

  11029. }

    11030. 

  11030. 

    11031. 

  11031.     //

    11032. 

  11032.     // send the given results to the given email addresses

    11033. 

  11033.     //

    11034. 

  11034. function SendResults($a_fld_order,$a_clean_fields,$s_to,$s_cc,$s_bcc,$a_raw_fields)

    11035. 

  11035. {

    11036. 

  11036.     global  $SPECIAL_VALUES,$aFileVars,$FILE_REPOSITORY,$FIXED_SENDER;

    11037. 

  11037. 

    11038. 

  11038.         //

    11039. 

  11039.         // check for a filter and how to use it

    11040. 

  11040.         //

    11041. 

  11041.     $b_filter_attach = false;

    11042. 

  11042.     $a_attach_spec = array();

    11043. 

  11043.     $s_filter = "";

    11044. 

  11044.     $a_filter_list = array();

    11045. 

  11045.     if ($b_got_filter = GetFilterSpec($s_filter,$a_filter_list))

    11046. 

  11046.     {

    11047. 

  11047.         if ($a_filter_list === false)

    11048. 

  11048.         {

    11049. 

  11049.                 //

    11050. 

  11050.                 // not a limited filter, so filter all fields

    11051. 

  11051.                 //

    11052. 

  11052.             $b_limited_filter = false;

    11053. 

  11053.             $a_filter_list = array();

    11054. 

  11054.         }

    11055. 

  11055.         else

    11056. 

  11056.             $b_limited_filter = true;

    11057. 

  11057.         FMDebug("SendResults: got filter '$s_filter', limited=$b_limited_filter");

    11058. 

  11058.         $s_filter_attach_name = GetFilterOption("Attach");

    11059. 

  11059.         if (isset($s_filter_attach_name))

    11060. 

  11060.              if (!is_string($s_filter_attach_name) || empty($s_filter_attach_name))

    11061. 

  11061.                 SendAlert(GetMessage(MSG_ATTACH_NAME));

    11062. 

  11062.             else

    11063. 

  11063.             {

    11064. 

  11064.                 $b_filter_attach = true;

    11065. 

  11065.                 $a_attach_spec = array("Name"=>$s_filter_attach_name);

    11066. 

  11066.                 if (($s_mime = GetFilterAttrib($s_filter,"MIME")) !== false)

    11067. 

  11067.                     $a_attach_spec["MIME"] = $s_mime;

    11068. 

  11068.                     //

    11069. 

  11069.                     // Regarding the character set...

    11070. 

  11070.                     // A filter will not generally change the character set

    11071. 

  11071.                     // of the message, however, if it does, then we

    11072. 

  11072.                     // provide that information to the MIME encoder.

    11073. 

  11073.                     // Remember: this character set specification refers

    11074. 

  11074.                     // to the data *after* the effect of the filter

    11075. 

  11075.                     // has been reversed (e.g. an encrypted message

    11076. 

  11076.                     // in UTF-8 is in UTF-8 when it is decrypted).

    11077. 

  11077.                     //

    11078. 

  11078.                 if (($s_cset = GetFilterAttrib($s_filter,"CharSet")) !== false)

    11079. 

  11079.                     $a_attach_spec["CharSet"] = $s_cset;

    11080. 

  11080.             }

    11081. 

  11081.     }

    11082. 

  11082. 

    11083. 

  11083.         //

    11084. 

  11084.         // check the need for MIME formatted mail

    11085. 

  11085.         //

    11086. 

  11086.     $b_mime_mail = (IsMailOptionSet("HTMLTemplate") || count($aFileVars) > 0 ||

    11087. 

  11087.                     $b_filter_attach);

    11088. 

  11088. 

    11089. 

  11089.         //

    11090. 

  11090.         // create the email header lines - CC, BCC, From, and Reply-To

    11091. 

  11091.         //

    11092. 

  11092.     $a_headers = array();

    11093. 

  11093.     if (!empty($s_cc))

    11094. 

  11094.         $a_headers['Cc'] = SafeHeader($s_cc);

    11095. 

  11095.     if (!empty($SPECIAL_VALUES["replyto"]))

    11096. 

  11096.     {

    11097. 

  11097.             //

    11098. 

  11098.             // expand replyto list

    11099. 

  11099.             //

    11100. 

  11100.         CheckEmailAddress($SPECIAL_VALUES["replyto"],$s_list,$s_invalid,false);

    11101. 

  11101.         if (!empty($s_list))

    11102. 

  11102.             $a_headers['Reply-To'] = SafeHeader($s_list);

    11103. 

  11103.     }

    11104. 

  11104.         //

    11105. 

  11105.         // note that BCC is documented to not work prior to PHP 4.3

    11106. 

  11106.         //

    11107. 

  11107.     if (!empty($s_bcc))

    11108. 

  11108.     {

    11109. 

  11109.         global  $aPHPVERSION;

    11110. 

  11110. 

    11111. 

  11111.         if ($aPHPVERSION[0] < 4 || ($aPHPVERSION[0] == 4 && $aPHPVERSION[1] < 3))

    11112. 

  11112.             SendAlert(GetMessage(MSG_PHP_BCC,

    11113. 

  11113.                             array("PHPVERS"=>implode(".",$aPHPVERSION))));

    11114. 

  11114.         $a_headers['Bcc'] = SafeHeader($s_bcc);

    11115. 

  11115.     }

    11116. 

  11116.         //

    11117. 

  11117.         // create the From address

    11118. 

  11118.         //

    11119. 

  11119.         // Some servers won't let you set the email address to the

    11120. 

  11120.         // submitter of the form.  Therefore, use FromAddr if it's been

    11121. 

  11121.         // specified to set the sender and the "From" address.

    11122. 

  11122.         //

    11123. 

  11123.     $s_sender = GetMailOption("FromAddr");

    11124. 

  11124.     if (!isset($s_sender))

    11125. 

  11125.     {

    11126. 

  11126.         $s_sender = "";

    11127. 

  11127.         if (!empty($SPECIAL_VALUES["email"]))

    11128. 

  11128.             $a_headers['From'] = MakeFromLine($SPECIAL_VALUES["email"],

    11129. 

  11129.                                             $SPECIAL_VALUES["realname"]);

    11130. 

  11130.     }

    11131. 

  11131.     elseif ($s_sender !== "")

    11132. 

  11132.         $s_sender = $a_headers['From'] = SafeHeader(UnMangle($s_sender));

    11133. 

  11133. 

    11134. 

  11134.         /* 

    11135. 

  11135.          * Override sender if $FIXED_SENDER is set.

    11136. 

  11136.          */

    11137. 

  11137.     if ($FIXED_SENDER !== "")

    11138. 

  11138.         $s_sender = $FIXED_SENDER;

    11139. 

  11139. 

    11140. 

  11140.     if ($s_sender === "")

    11141. 

  11141.         if (SET_SENDER_FROM_EMAIL)

    11142. 

  11142.             $s_sender = $SPECIAL_VALUES["email"];

    11143. 

  11143. 

    11144. 

  11144.         //

    11145. 

  11145.         // special case: if there is only one non-special string value, then

    11146. 

  11146.         // format it as an email (unless an option says not to)

    11147. 

  11147.         //

    11148. 

  11148.     $a_keys = array_keys($a_raw_fields);

    11149. 

  11149.     if (count($a_keys) == 1 && is_string($a_raw_fields[$a_keys[0]]) &&

    11150. 

  11150.         !IsMailOptionSet("AlwaysList") && !IsMailOptionSet("DupHeader"))

    11151. 

  11151.     {

    11152. 

  11152.         if (IsMailExcluded($a_keys[0]))

    11153. 

  11153.             SendAlert("Exclusion of single field '".$a_keys[0]."' ignored");

    11154. 

  11154.         $s_value = $a_raw_fields[$a_keys[0]];

    11155. 

  11155.             //

    11156. 

  11156.             // replace carriage return/linefeeds with <br>

    11157. 

  11157.             //

    11158. 

  11158.         $s_value = str_replace("\r\n",'<br />',$s_value);

    11159. 

  11159.             //

    11160. 

  11160.             // replace lone linefeeds with <br>

    11161. 

  11161.             //

    11162. 

  11162.         $s_value = str_replace("\n",'<br />',$s_value);

    11163. 

  11163.             //

    11164. 

  11164.             // remove lone carriage returns

    11165. 

  11165.             //

    11166. 

  11166.         $s_value = str_replace("\r","",$s_value);

    11167. 

  11167.             //

    11168. 

  11168.             // replace all control chars with <br />

    11169. 

  11169.             //

    11170. 

  11170.         $s_value = preg_replace('/[[:cntrl:]]+/','<br />',$s_value);

    11171. 

  11171.             //

    11172. 

  11172.             // strip HTML (note that all the <br> above will now be

    11173. 

  11173.             // replaced with BODY_LF)

    11174. 

  11174.             //

    11175. 

  11175.         $s_value = StripHTML($s_value,BODY_LF);

    11176. 

  11176. 

    11177. 

  11177.         if ($b_mime_mail)

    11178. 

  11178.         {

    11179. 

  11179.             if ($b_got_filter)

    11180. 

  11180.             {

    11181. 

  11181.                     //

    11182. 

  11182.                     // filter the whole value (ignore filter_fields for this

    11183. 

  11183.                     // special case) if a filter has been specified

    11184. 

  11184.                     //

    11185. 

  11185.                 $s_results = Filter($s_filter,$s_value);

    11186. 

  11186.                 if ($b_filter_attach)

    11187. 

  11187.                 {

    11188. 

  11188.                     $a_attach_spec["Data"] = $s_results;

    11189. 

  11189.                         //

    11190. 

  11190.                         // KeepInLine keeps the filtered version inline as well

    11191. 

  11191.                         // as an attachment

    11192. 

  11192.                         //

    11193. 

  11193.                     if (!IsFilterOptionSet("KeepInLine"))

    11194. 

  11194.                         $s_results = "";

    11195. 

  11195.                     $s_filter = ""; // no more filtering

    11196. 

  11196.                 }

    11197. 

  11197.             }

    11198. 

  11198.             else

    11199. 

  11199.                 $s_results = $s_value;

    11200. 

  11200. 

    11201. 

  11201.                 //

    11202. 

  11202.                 // send this single value off to get formatted in a MIME

    11203. 

  11203.                 // email

    11204. 

  11204.                 //

    11205. 

  11205.             if (!MakeMimeMail($s_results,$a_headers,$a_raw_fields,

    11206. 

  11206.                                 GetMailOption('HTMLTemplate'),

    11207. 

  11207.                                 GetMailOption('TemplateMissing'),

    11208. 

  11208.                                 IsMailOptionSet("NoPlain"),

    11209. 

  11209.                                 $s_filter,$aFileVars,$a_attach_spec))

    11210. 

  11210.                 return (false);

    11211. 

  11211.         }

    11212. 

  11212.         elseif ($b_got_filter)

    11213. 

  11213.                 //

    11214. 

  11214.                 // filter the whole value (ignore filter_fields for this special case)

    11215. 

  11215.                 // if a filter has been specified

    11216. 

  11216.                 //

    11217. 

  11217.             $s_results = Filter($s_filter,$s_value);

    11218. 

  11218.         else

    11219. 

  11219.         {

    11220. 

  11220.             $s_results = $s_value;

    11221. 

  11221.             if (IsMailOptionSet("CharSet"))

    11222. 

  11222.                     //

    11223. 

  11223.                     // sending plain text email, and the CharSet has been

    11224. 

  11224.                     // specified; include a header

    11225. 

  11225.                     //

    11226. 

  11226.                 $a_headers['Content-Type'] = "text/plain; charset=".SafeHeader(GetMailOption("CharSet"));

    11227. 

  11227.         }

    11228. 

  11228.     }

    11229. 

  11229.     else

    11230. 

  11230.     {

    11231. 

  11231.         if ($b_mime_mail)

    11232. 

  11232.         {

    11233. 

  11233.                 //

    11234. 

  11234.                 // get the plain text version of the email then send it

    11235. 

  11235.                 // to get MIME formatted

    11236. 

  11236.                 //

    11237. 

  11237.             list($s_results,$s_unfiltered_results,$s_filtered_results) =

    11238. 

  11238.                             MakePlainEmail($a_fld_order,$a_clean_fields,

    11239. 

  11239.                                 $s_to,$s_cc,$s_bcc,$a_raw_fields,$s_filter,

    11240. 

  11240.                                 $a_filter_list);

    11241. 

  11241.             if ($b_filter_attach)

    11242. 

  11242.             {

    11243. 

  11243.                     //

    11244. 

  11244.                     // attached the filtered results

    11245. 

  11245.                     //

    11246. 

  11246.                 $a_attach_spec["Data"] = $s_filtered_results;

    11247. 

  11247.                     //

    11248. 

  11248.                     // KeepInLine keeps the filtered version inline as well

    11249. 

  11249.                     // as an attachment

    11250. 

  11250.                     //

    11251. 

  11251.                 if (!IsFilterOptionSet("KeepInLine"))

    11252. 

  11252.                         //

    11253. 

  11253.                         // put the unfiltered results in the body of the message

    11254. 

  11254.                         //

    11255. 

  11255.                     $s_results = $s_unfiltered_results;

    11256. 

  11256.                 $s_filter = ""; // no more filtering

    11257. 

  11257.             }

    11258. 

  11258.             if (!MakeMimeMail($s_results,$a_headers,$a_raw_fields,

    11259. 

  11259.                                 GetMailOption('HTMLTemplate'),

    11260. 

  11260.                                 GetMailOption('TemplateMissing'),

    11261. 

  11261.                                 IsMailOptionSet("NoPlain"),

    11262. 

  11262.                                 $s_filter,$aFileVars,$a_attach_spec))

    11263. 

  11263.                 return (false);

    11264. 

  11264.         }

    11265. 

  11265.         else

    11266. 

  11266.         {

    11267. 

  11267.             list($s_results,$s_unfiltered_results,$s_filtered_results) =

    11268. 

  11268.                             MakePlainEmail($a_fld_order,$a_clean_fields,

    11269. 

  11269.                                 $s_to,$s_cc,$s_bcc,$a_raw_fields,$s_filter,

    11270. 

  11270.                                 $a_filter_list);

    11271. 

  11271.             if (!$b_got_filter && IsMailOptionSet("CharSet"))

    11272. 

  11272.                     //

    11273. 

  11273.                     // sending plain text email, and the CharSet has been

    11274. 

  11274.                     // specified; include a header

    11275. 

  11275.                     //

    11276. 

  11276.                 $a_headers['Content-Type'] = "text/plain; charset=".SafeHeader(GetMailOption("CharSet"));

    11277. 

  11277.         }

    11278. 

  11278.     }

    11279. 

  11279. 

    11280. 

  11280.         //

    11281. 

  11281.         // now save uploaded files to the repository

    11282. 

  11282.         //

    11283. 

  11283.     if (FILEUPLOADS && $FILE_REPOSITORY !== "")

    11284. 

  11284.         if (!SaveAllFilesToRepository())

    11285. 

  11285.             return (false);

    11286. 

  11286. 

    11287. 

  11287.         //

    11288. 

  11288.         // send the mail - assumes the email addresses have already been checked

    11289. 

  11289.         //

    11290. 

  11290.     return (SendCheckedMail($s_to,$SPECIAL_VALUES["subject"],$s_results,

    11291. 

  11291.                                     $s_sender,$a_headers));

    11292. 

  11292. }

    11293. 

  11293. 

    11294. 

  11294.     //

    11295. 

  11295.     // append an entry to a log file

    11296. 

  11296.     //

    11297. 

  11297. function WriteLog($log_file)

    11298. 

  11298. {

    11299. 

  11299.     global  $SPECIAL_VALUES,$php_errormsg;

    11300. 

  11300. 

    11301. 

  11301. @   $log_fp = fopen($log_file,"a");

    11302. 

  11302.     if ($log_fp === false)

    11303. 

  11303.     {

    11304. 

  11304.         SendAlert(GetMessage(MSG_FILE_OPEN_ERROR,array("NAME"=>$log_file,

    11305. 

  11305.                                             "TYPE"=>"log",

    11306. 

  11306.                                             "ERROR"=>CheckString($php_errormsg))));

    11307. 

  11307.         return;

    11308. 

  11308.     }

    11309. 

  11309.     $date = gmdate("H:i:s d-M-y T");

    11310. 

  11310.     $entry = $date.":".$SPECIAL_VALUES["email"].",".

    11311. 

  11311.             $SPECIAL_VALUES["realname"].",".$SPECIAL_VALUES["subject"]."\n";

    11312. 

  11312.     fwrite($log_fp,$entry);

    11313. 

  11313.     fclose($log_fp);

    11314. 

  11314. }

    11315. 

  11315. 

    11316. 

  11316.     //

    11317. 

  11317.     // write the data to a comma-separated-values file

    11318. 

  11318.     //

    11319. 

  11319. function WriteCSVFile($s_csv_file,$a_vars)

    11320. 

  11320. {

    11321. 

  11321.     global  $SPECIAL_VALUES,$CSVSEP,$CSVINTSEP,$CSVQUOTE,$CSVOPEN,$CSVLINE;

    11322. 

  11322. 

    11323. 

  11323.         //

    11324. 

  11324.         // create an array of column values in the order specified

    11325. 

  11325.         // in $SPECIAL_VALUES["csvcolumns"]

    11326. 

  11326.         //

    11327. 

  11327.     $a_column_list = $SPECIAL_VALUES["csvcolumns"];

    11328. 

  11328.     if (!isset($a_column_list) || empty($a_column_list) || !is_string($a_column_list))

    11329. 

  11329.     {

    11330. 

  11330.         SendAlert(GetMessage(MSG_CSVCOLUMNS,array("VALUE"=>$a_column_list)));

    11331. 

  11331.         return;

    11332. 

  11332.     }

    11333. 

  11333.     if (!isset($s_csv_file) || empty($s_csv_file) || !is_string($s_csv_file))

    11334. 

  11334.     {

    11335. 

  11335.         SendAlert(GetMessage(MSG_CSVFILE,array("VALUE"=>$s_csv_file)));

    11336. 

  11336.         return;

    11337. 

  11337.     }

    11338. 

  11338. 

    11339. 

  11339. @   $fp = fopen($s_csv_file,"a".$CSVOPEN);

    11340. 

  11340.     if ($fp === false)

    11341. 

  11341.     {

    11342. 

  11342.         SendAlert(GetMessage(MSG_FILE_OPEN_ERROR,array("NAME"=>$s_csv_file,

    11343. 

  11343.                                             "TYPE"=>"CSV",

    11344. 

  11344.                                             "ERROR"=>CheckString($php_errormsg))));

    11345. 

  11345.         return;

    11346. 

  11346.     }

    11347. 

  11347. 

    11348. 

  11348.         //

    11349. 

  11349.         // convert the column list to an array, trim the names too

    11350. 

  11350.         //

    11351. 

  11351.     $a_column_list = TrimArray(explode(",",$a_column_list));

    11352. 

  11352.     $n_columns = count($a_column_list);

    11353. 

  11353. 

    11354. 

  11354.         //

    11355. 

  11355.         // if the file is currently empty, put the column names in the first line

    11356. 

  11356.         //

    11357. 

  11357.     $b_heading = false;

    11358. 

  11358.     if (filesize($s_csv_file) == 0)

    11359. 

  11359.         $b_heading = true;

    11360. 

  11360. 

    11361. 

  11361.     $csv_format = new CSVFormat();

    11362. 

  11362.         

    11363. 

  11363.         //

    11364. 

  11364.         // now configure the CSVFormat object

    11365. 

  11365.         // according to FormMail's configuration settings

    11366. 

  11366.         //

    11367. 

  11367.     $csv_format->SetQuote($CSVQUOTE);

    11368. 

  11368.     $csv_format->SetEscPolicy("conv");

    11369. 

  11369.     $csv_format->SetSep($CSVSEP);

    11370. 

  11370.     $csv_format->SetIntSep($CSVINTSEP);

    11371. 

  11371.     if (LIMITED_IMPORT)

    11372. 

  11372.         $csv_format->SetCleanFunc(create_function('$m_value',

    11373. 

  11373.                                     'return CleanValue($m_value);'));

    11374. 

  11374. 

    11375. 

  11375.     $s_csv = $csv_format->MakeCSVRecord($a_column_list,$a_vars);

    11376. 

  11376. 

    11377. 

  11377.     if ($b_heading)

    11378. 

  11378.         fwrite($fp,$csv_format->MakeHeading($a_column_list).$CSVLINE);

    11379. 

  11379. 

    11380. 

  11380.     fwrite($fp,$s_csv.$CSVLINE);

    11381. 

  11381.     fclose($fp);

    11382. 

  11382. //  CreatePage($debug);

    11383. 

  11383. //  exit;

    11384. 

  11384. }

    11385. 

  11385. 

    11386. 

  11386. function CheckConfig()

    11387. 

  11387. {

    11388. 

  11388.     global  $TARGET_EMAIL,$CONFIG_CHECK;

    11389. 

  11389. 

    11390. 

  11390.     $a_mesgs = array();

    11391. 

  11391.     if (in_array("TARGET_EMAIL",$CONFIG_CHECK))

    11392. 

  11392.     {

    11393. 

  11393.             //

    11394. 

  11394.             // $TARGET_EMAIL values should begin with ^ and end with $

    11395. 

  11395.             //

    11396. 

  11396.         for ($ii = 0 ; $ii < count($TARGET_EMAIL) ; $ii++)

    11397. 

  11397.         {

    11398. 

  11398.             $s_pattern = $TARGET_EMAIL[$ii];

    11399. 

  11399.             if (substr($s_pattern,0,1) != '^')

    11400. 

  11400.                 $a_mesgs[] = GetMessage(MSG_TARG_EMAIL_PAT_START,

    11401. 

  11401.                                         array("PAT"=>$s_pattern));

    11402. 

  11402.             if (substr($s_pattern,-1) != '$')

    11403. 

  11403.                 $a_mesgs[] = GetMessage(MSG_TARG_EMAIL_PAT_END,

    11404. 

  11404.                                         array("PAT"=>$s_pattern));

    11405. 

  11405.         }

    11406. 

  11406.     }

    11407. 

  11407.     if (count($a_mesgs) > 0)

    11408. 

  11408.         SendAlert(GetMessage(MSG_CONFIG_WARN,

    11409. 

  11409.                         array("MESGS"=>implode("\n",$a_mesgs))),false,true);

    11410. 

  11410. }

    11411. 

  11411. 

    11412. 

  11412.     //

    11413. 

  11413.     // append an entry to the Auto Responder log file

    11414. 

  11414.     //

    11415. 

  11415. function WriteARLog($s_to,$s_subj,$s_info)

    11416. 

  11416. {

    11417. 

  11417.     global  $LOGDIR,$AUTORESPONDLOG,$aServerVars,$php_errormsg;

    11418. 

  11418. 

    11419. 

  11419.     if (!isset($LOGDIR) || !isset($AUTORESPONDLOG) ||

    11420. 

  11420.             empty($LOGDIR) || empty($AUTORESPONDLOG))

    11421. 

  11421.         return;

    11422. 

  11422. 

    11423. 

  11423.     $log_file = $LOGDIR."/".$AUTORESPONDLOG;

    11424. 

  11424. @   $log_fp = fopen($log_file,"a");

    11425. 

  11425.     if ($log_fp === false)

    11426. 

  11426.     {

    11427. 

  11427.         SendAlert(GetMessage(MSG_FILE_OPEN_ERROR,array("NAME"=>$log_file,

    11428. 

  11428.                                             "TYPE"=>"log",

    11429. 

  11429.                                             "ERROR"=>CheckString($php_errormsg))));

    11430. 

  11430.         return;

    11431. 

  11431.     }

    11432. 

  11432.     $a_entry = array();

    11433. 

  11433.     $a_entry[] = gmdate("H:i:s d-M-y T");       // date/time in GMT

    11434. 

  11434.     $a_entry[] = $aServerVars['REMOTE_ADDR'];   // remote IP address

    11435. 

  11435.     $a_entry[] = $s_to;                         // target email address

    11436. 

  11436.     $a_entry[] = $s_subj;                       // subject line

    11437. 

  11437.     $a_entry[] = $s_info;                       // information

    11438. 

  11438. 

    11439. 

  11439.     $s_log_entry = implode(",",$a_entry)."\n";

    11440. 

  11440.     fwrite($log_fp,$s_log_entry);

    11441. 

  11441.     fclose($log_fp);

    11442. 

  11442. }

    11443. 

  11443. 

    11444. 

  11444. /*

    11445. 

  11445.  * The main logic starts here....

    11446. 

  11446.  */

    11447. 

  11447. 

    11448. 

  11448.     //

    11449. 

  11449.     // First, a special case; if formmail.php is called like this:

    11450. 

  11450.     //  http://.../formmail.php?testalert=1

    11451. 

  11451.     // it sends a test message to the default alert address with some

    11452. 

  11452.     // information about your PHP version and the DOCUMENT_ROOT.

    11453. 

  11453.     //

    11454. 

  11454. if (isset($aGetVars["testalert"]) && $aGetVars["testalert"] == 1)

    11455. 

  11455. {

    11456. 

  11456.     function ShowServerVar($s_name)

    11457. 

  11457.     {

    11458. 

  11458.         global  $aServerVars;

    11459. 

  11459. 

    11460. 

  11460.         return (isset($aServerVars[$s_name]) ? $aServerVars[$s_name] : "-not set-");

    11461. 

  11461.     }

    11462. 

  11462.     $sAlert = GetMessage(MSG_ALERT,

    11463. 

  11463.                 array("LANG"=>$sLangID,

    11464. 

  11464.                       "PHPVERS"=>implode(".",$aPHPVERSION),

    11465. 

  11465.                       "FM_VERS"=>$FM_VERS,

    11466. 

  11466.                       "SERVER"=>(IsServerWindows() ? "Windows" : "non-Windows"),

    11467. 

  11467.                       "DOCUMENT_ROOT"=>ShowServerVar('DOCUMENT_ROOT'),

    11468. 

  11468.                       "SCRIPT_FILENAME"=>ShowServerVar('SCRIPT_FILENAME'),

    11469. 

  11469.                       "PATH_TRANSLATED"=>ShowServerVar('PATH_TRANSLATED'),

    11470. 

  11470.                       "REAL_DOCUMENT_ROOT"=>CheckString($REAL_DOCUMENT_ROOT),

    11471. 

  11471.                      ));

    11472. 

  11472. 

    11473. 

  11473.     if (DEF_ALERT == "")

    11474. 

  11474.         echo "<p>".GetMessage(MSG_NO_DEF_ALERT)."</p>";

    11475. 

  11475.     elseif (SendAlert($sAlert,false,true))

    11476. 

  11476.         echo "<p>".GetMessage(MSG_TEST_SENT)."</p>";

    11477. 

  11477.     else

    11478. 

  11478.         echo "<p>".GetMessage(MSG_TEST_FAILED)."</p>";

    11479. 

  11479.     exit;

    11480. 

  11480. }

    11481. 

  11481. 

    11482. 

  11482. if (isset($aGetVars["testlang"]) && $aGetVars["testlang"] == 1)

    11483. 

  11483. {

    11484. 

  11484.     if (!IsPHPAtLeast("4.1.0"))

    11485. 

  11485.     {

    11486. 

  11486.     ?>

    11487. 

  11487.         <p>testlang feature only works with PHP version 4.1.0 or later</p>

    11488. 

  11488.     <?php

    11489. 

  11489.     }

    11490. 

  11490.     else

    11491. 

  11491.     {

    11492. 

  11492.         function ShowMessages()

    11493. 

  11493.         {

    11494. 

  11494.             global  $aMessages,$sLangID,$bShowMesgNumbers,$aGetVars,$sHTMLCharSet;

    11495. 

  11495. 

    11496. 

  11496.                 //

    11497. 

  11497.                 // force message numbers on unless "mnums=no"

    11498. 

  11498.                 //

    11499. 

  11499.             if (isset($aGetVars["mnums"]) && $aGetVars["mnums"] == "no")

    11500. 

  11500.                 $bShowMesgNumbers = false;

    11501. 

  11501.             else

    11502. 

  11502.                 $bShowMesgNumbers = true;

    11503. 

  11503. 

    11504. 

  11504.             LoadBuiltinLanguage();

    11505. 

  11505. 

    11506. 

  11506.             $s_def_lang = $sLangID;

    11507. 

  11507.             $a_def_mesgs = $aMessages;

    11508. 

  11508. 

    11509. 

  11509.             LoadLanguageFile();

    11510. 

  11510. 

    11511. 

  11511.             $s_active_lang = $sLangID;

    11512. 

  11512.             $a_active_mesgs = $aMessages;

    11513. 

  11513. 

    11514. 

  11514.             $a_list = get_defined_constants();

    11515. 

  11515. 

    11516. 

  11516.             echo "<html>\n";

    11517. 

  11517.             echo "<head>\n";

    11518. 

  11518.             if (isset($sHTMLCharSet) && $sHTMLCharSet !== "")

    11519. 

  11519.                 echo "<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=$sHTMLCharSet\">\n";

    11520. 

  11520.             echo "</head>\n";

    11521. 

  11521.             echo "<body>\n";

    11522. 

  11522. 

    11523. 

  11523.             echo "<table border=\"1\" cellpadding=\"10\" width=\"95%\">\n";

    11524. 

  11524.             echo "<tr>\n";

    11525. 

  11525.             echo "<th>\n";

    11526. 

  11526.             echo "Message Number";

    11527. 

  11527.             echo "</th>\n";

    11528. 

  11528.             echo "<th>\n";

    11529. 

  11529.             echo "$s_def_lang";

    11530. 

  11530.             echo "</th>\n";

    11531. 

  11531.             echo "<th>\n";

    11532. 

  11532.             echo "$s_active_lang";

    11533. 

  11533.             echo "</th>\n";

    11534. 

  11534.             echo "</tr>\n";

    11535. 

  11535.             foreach ($a_list as $s_name=>$i_value)

    11536. 

  11536.             {

    11537. 

  11537.                 if (substr($s_name,0,4) == "MSG_")

    11538. 

  11538.                 {

    11539. 

  11539.                         //

    11540. 

  11540.                         // some PHP constants begin with MSG_, so we try to skip them too

    11541. 

  11541.                         //

    11542. 

  11542.                     switch ($s_name)

    11543. 

  11543.                     {

    11544. 

  11544.                     case "MSG_IPC_NOWAIT":

    11545. 

  11545.                     case "MSG_EAGAIN":

    11546. 

  11546.                     case "MSG_ENOMSG":

    11547. 

  11547.                     case "MSG_NOERROR":

    11548. 

  11548.                     case "MSG_EXCEPT":

    11549. 

  11549.                     case "MSG_OOB":

    11550. 

  11550.                     case "MSG_PEEK":

    11551. 

  11551.                     case "MSG_DONTROUTE":

    11552. 

  11552.                     case "MSG_EOR":

    11553. 

  11553.                         continue 2;

    11554. 

  11554.                     }

    11555. 

  11555.                     if ($i_value >= 256)

    11556. 

  11556.                         continue;

    11557. 

  11557.                     echo "<tr>\n";

    11558. 

  11558.                     echo "<td valign=\"top\">\n";

    11559. 

  11559.                     echo "$s_name ($i_value)";

    11560. 

  11560.                     echo "</td>\n";

    11561. 

  11561.                     echo "<td valign=\"top\">\n";

    11562. 

  11562.                     $aMessages = $a_def_mesgs;

    11563. 

  11563.                     $s_def_msg = GetMessage((int) $i_value,array(),true,true);

    11564. 

  11564.                     echo nl2br(htmlentities($s_def_msg));       // English - don't need FixedHTMLEntities

    11565. 

  11565.                     echo "</td>\n";

    11566. 

  11566.                     echo "<td valign=\"top\">\n";

    11567. 

  11567.                     $aMessages = $a_active_mesgs;

    11568. 

  11568.                     $s_act_msg = GetMessage((int) $i_value,array(),true,true);

    11569. 

  11569.                     if ($s_def_msg == $s_act_msg)

    11570. 

  11570.                         echo "<i>identical</i>\n";

    11571. 

  11571.                     else

    11572. 

  11572.                         echo nl2br(FixedHTMLEntities($s_act_msg));

    11573. 

  11573.                     echo "</td>\n";

    11574. 

  11574.                     echo "</tr>\n";

    11575. 

  11575.                 }

    11576. 

  11576.             }

    11577. 

  11577.             echo "</table>\n";

    11578. 

  11578. 

    11579. 

  11579.             echo "</body>\n";

    11580. 

  11580.             echo "</html>\n";

    11581. 

  11581.         }

    11582. 

  11582.         ShowMessages();

    11583. 

  11583.     }

    11584. 

  11584.     exit;

    11585. 

  11585. }

    11586. 

  11586. 

    11587. 

  11587.     //

    11588. 

  11588.     // For saved files, add in the "new_name" values to the given

    11589. 

  11589.     // array.

    11590. 

  11590.     //

    11591. 

  11591. function    GetSavedFileNames($a_values)

    11592. 

  11592. {

    11593. 

  11593.     if (IsSetSession("FormSavedFiles"))

    11594. 

  11594.     {

    11595. 

  11595.         $a_saved_files = GetSession("FormSavedFiles");

    11596. 

  11596.         foreach ($a_saved_files as $s_fld=>$a_upload)

    11597. 

  11597.         {

    11598. 

  11598.             if (isset($a_upload["name"]))

    11599. 

  11599.                 $a_values[$s_fld] = $a_upload["name"];

    11600. 

  11600.             if (isset($a_upload["new_name"]))

    11601. 

  11601.                 $a_values["name_of_$s_fld"] = $a_upload["new_name"];

    11602. 

  11602.         }

    11603. 

  11603.     }

    11604. 

  11604.     return ($a_values);

    11605. 

  11605. }

    11606. 

  11606. 

    11607. 

  11607.     //

    11608. 

  11608.     // Scan the Multi form sequence values and build up the values that

    11609. 

  11609.     // were submitted to the given form index.

    11610. 

  11610.     //

    11611. 

  11611. function GetMultiValues($a_form_list,$i_form_index,$a_order = array(),

    11612. 

  11612.                                             $a_clean = array(),

    11613. 

  11613.                                             $a_raw_data = array(),

    11614. 

  11614.                                             $a_all_data = array(),

    11615. 

  11615.                                             $a_file_data = array())

    11616. 

  11616. {

    11617. 

  11617.     $a_ret_clean = $a_ret_raw = $a_ret_all = $a_ret_files = array();

    11618. 

  11618.     for ($ii = 0 ; $ii < $i_form_index ; $ii++)

    11619. 

  11619.     {

    11620. 

  11620.             //

    11621. 

  11621.             // only add a field to the order if it's not already there

    11622. 

  11622.             //

    11623. 

  11623.         $a_form_order = $a_form_list[$ii]["ORDER"];

    11624. 

  11624.         $n_order = count($a_form_order);

    11625. 

  11625.         for ($jj = 0 ; $jj < $n_order ; $jj++)

    11626. 

  11626.         {

    11627. 

  11627.             if (array_search($a_form_order[$jj],$a_order) === false)

    11628. 

  11628.                 $a_order[] = $a_form_order[$jj];

    11629. 

  11629.         }

    11630. 

  11630.         $a_ret_clean = array_merge($a_ret_clean,$a_form_list[$ii]["CLEAN"]);

    11631. 

  11631.         $a_ret_raw = array_merge($a_ret_raw,$a_form_list[$ii]["RAWDATA"]);

    11632. 

  11632.         $a_ret_all = array_merge($a_ret_all,$a_form_list[$ii]["ALLDATA"]);

    11633. 

  11633.         $a_ret_files = array_merge($a_ret_files,$a_form_list[$ii]["FILES"]);

    11634. 

  11634.     }

    11635. 

  11635.         //

    11636. 

  11636.         // later values must take precedence to earlier values,

    11637. 

  11637.         // so merge in the passed-in data last

    11638. 

  11638.         //

    11639. 

  11639.     $a_ret_clean = array_merge($a_ret_clean,$a_clean);

    11640. 

  11640.     $a_ret_raw = array_merge($a_ret_raw,$a_raw_data);

    11641. 

  11641.     $a_ret_all = array_merge($a_ret_all,$a_all_data);

    11642. 

  11642.     $a_ret_files = array_merge($a_ret_files,$a_file_data);

    11643. 

  11643.     return (array($a_order,$a_ret_clean,$a_ret_raw,$a_ret_all,$a_ret_files));

    11644. 

  11644. }

    11645. 

  11645. 

    11646. 

  11646. $bMultiForm = false;

    11647. 

  11647. 

    11648. 

  11648.     //

    11649. 

  11649.     // Multi-page form sequencing is complicated....

    11650. 

  11650.     // Requirements:

    11651. 

  11651.     //      1. The first page in a multi-page form sequence must provide:

    11652. 

  11652.     //          - multi_start field set to 1

    11653. 

  11653.     //          - this_form field (it's own URL)

    11654. 

  11654.     //          - next_form field (multi-page form template name)

    11655. 

  11655.     //      2. Subsequent pages must provide either:

    11656. 

  11656.     //          next_form (the next template name in the sequence)

    11657. 

  11657.     //         OR

    11658. 

  11658.     //          good_url or good_template or neither; this terminates

    11659. 

  11659.     //          the multi-page processing and provides the final URL.

    11660. 

  11660.     // Logic:

    11661. 

  11661.     //      1. We create session variables to contain information about

    11662. 

  11662.     //         the sequence.

    11663. 

  11663.     //      2. On the first submission from the starting form, we record

    11664. 

  11664.     //         its "this_form" URL and the data submitted.

    11665. 

  11665.     //         We also create a URL (to FormMail) that will allow return

    11666. 

  11666.     //         to the *next* form in the sequence.

    11667. 

  11667.     //      3. On submission from other forms in the sequence, we record

    11668. 

  11668.     //         the data that was submitted so we can return to that

    11669. 

  11669.     //         form with the user's data re-filled into the form.

    11670. 

  11670.     //         We also create a URL (to FormMail) that will allow return

    11671. 

  11671.     //         to the *next* form in the sequence.

    11672. 

  11672.     //      4. A return URL contains "return=index" where index is the

    11673. 

  11673.     //         form sequence index number.  This is a URL to FormMail.

    11674. 

  11674.     //         FormMail gets the template name or URL (URL only for the

    11675. 

  11675.     //         starting form) and outputs the requested HTML form.  It also

    11676. 

  11676.     //         truncates the session data for forms after the returned-to

    11677. 

  11677.     //         one.

    11678. 

  11678.     //

    11679. 

  11679. 

    11680. 

  11680.     //

    11681. 

  11681.     // Return to a previous form in a sequence.

    11682. 

  11682.     //

    11683. 

  11683. function MultiFormReturn($i_return_to)

    11684. 

  11684. {

    11685. 

  11685.     global  $iFormIndex;

    11686. 

  11686.     global  $SessionAccessor;

    11687. 

  11687. 

    11688. 

  11688.     if (!IsSetSession("FormList") ||

    11689. 

  11689.            !IsSetSession("FormIndex") ||

    11690. 

  11690.             $i_return_to < 0 ||

    11691. 

  11691.             $i_return_to > GetSession("FormIndex"))

    11692. 

  11692.         Error("cannot_return",GetMessage(MSG_CANNOT_RETURN,

    11693. 

  11693.                                 array("TO"=>$i_return_to,

    11694. 

  11694.                                     "TOPINDEX"=>(

    11695. 

  11695.                                         IsSetSession("FormIndex") ?

    11696. 

  11696.                                         GetSession("FormIndex") :

    11697. 

  11697.                                         "<undefined>"))),

    11698. 

  11698.                                 false,false);

    11699. 

  11699.     $a_list = GetSession("FormList");

    11700. 

  11700.     assert($i_return_to < count($a_list));

    11701. 

  11701.     $a_form_def = $a_list[$i_return_to];

    11702. 

  11702.     SetSession("FormList",$a_list = array_slice($a_list,0,$i_return_to+1));

    11703. 

  11703.     SetSession("FormIndex",$iFormIndex = $i_return_to);

    11704. 

  11704.     if (isset($a_form_def["FORM"]))

    11705. 

  11705.     {

    11706. 

  11706.             //

    11707. 

  11707.             // get the values that were originally submitted to this form

    11708. 

  11708.             //

    11709. 

  11709.         list(,,$a_values,,) = GetMultiValues($a_list,$i_return_to);

    11710. 

  11710.             //

    11711. 

  11711.             // get the session values

    11712. 

  11712.             //

    11713. 

  11713.         $SessionAccessor->CopyIn($a_values,true);

    11714. 

  11714.         $a_lines = array();

    11715. 

  11715.             //

    11716. 

  11716.             // process the page as a template

    11717. 

  11717.             //

    11718. 

  11718.         if (ProcessMultiFormTemplate($a_form_def["FORM"],$a_values,$a_lines))

    11719. 

  11719.         {

    11720. 

  11720.             $n_lines = count($a_lines);

    11721. 

  11721.             $s_buf = "";

    11722. 

  11722.             for ($ii = 0 ; $ii < $n_lines ; $ii++)

    11723. 

  11723.             {

    11724. 

  11724.                 $s_buf .= $a_lines[$ii]."\n";

    11725. 

  11725.                 unset($a_lines[$ii]);       // free memory (hopefully)

    11726. 

  11726.             }

    11727. 

  11727.             unset($a_lines);       // free memory (hopefully)

    11728. 

  11728.                 //

    11729. 

  11729.                 // put in the values that the user previously submitted

    11730. 

  11730.                 // to this form

    11731. 

  11731.                 //

    11732. 

  11732.             echo SetPreviousValues($s_buf,$a_form_def["RAWDATA"]);

    11733. 

  11733.         }

    11734. 

  11734.         else

    11735. 

  11735.             Error("multi_form_failed",GetMessage(MSG_MULTIFORM_FAILED,

    11736. 

  11736.                                     array("NAME"=>$s_template)),false,false);

    11737. 

  11737.     }

    11738. 

  11738.     else

    11739. 

  11739.             //

    11740. 

  11740.             // we probably should include 

    11741. 

  11741.             //  $SessionAccessor->CopyIn(...,true);

    11742. 

  11742.             // at some stage in the future to get the session values....need to think about this

    11743. 

  11743.             // and run some case studies.

    11744. 

  11744.             //

    11745. 

  11745.         ProcessReturnToForm($a_form_def["URL"],$a_form_def["RAWDATA"],array("multi_start"));

    11746. 

  11746.     //echo "Returned to $i_return_to";

    11747. 

  11747. }

    11748. 

  11748. 

    11749. 

  11749.     //

    11750. 

  11750.     // Store any data just submitted and specified as "multi_keep".

    11751. 

  11751.     //

    11752. 

  11752. function MultiKeep()

    11753. 

  11753. {

    11754. 

  11754.     global  $SPECIAL_VALUES,$aRawDataValues;

    11755. 

  11755. 

    11756. 

  11756.     if (isset($SPECIAL_VALUES["multi_keep"]) &&

    11757. 

  11757.         !empty($SPECIAL_VALUES["multi_keep"]))

    11758. 

  11758.     {

    11759. 

  11759.         $a_list = TrimArray(explode(",",$SPECIAL_VALUES["multi_keep"]));

    11760. 

  11760.         if (IsSetSession("FormKeep"))

    11761. 

  11761.             $a_keep = GetSession("FormKeep");

    11762. 

  11762.         else

    11763. 

  11763.             $a_keep = array();

    11764. 

  11764.             //

    11765. 

  11765.             // For each data field specified in "multi_keep" store its

    11766. 

  11766.             // value in the FormKeep session variable.

    11767. 

  11767.             // If a field is specified and does not exist in the

    11768. 

  11768.             // recent submission, its value is discarded.

    11769. 

  11769.             //

    11770. 

  11770.         foreach ($a_list as $s_fld_name)

    11771. 

  11771.             if (!empty($s_fld_name))

    11772. 

  11772.                 if (isset($aRawDataValues[$s_fld_name]))

    11773. 

  11773.                     $a_keep[$s_fld_name] = $aRawDataValues[$s_fld_name];

    11774. 

  11774.                 else

    11775. 

  11775.                     unset($a_keep[$s_fld_name]);

    11776. 

  11776.         SetSession("FormKeep",$a_keep);

    11777. 

  11777.     }

    11778. 

  11778. }

    11779. 

  11779. 

    11780. 

  11780.     //

    11781. 

  11781.     // Perform Logic for Multi-Page form sequences

    11782. 

  11782.     //

    11783. 

  11783. function MultiFormLogic()

    11784. 

  11784. {

    11785. 

  11785.     global  $bMultiForm,$SPECIAL_VALUES,$aServerVars,$aFileVars;

    11786. 

  11786.     global  $sFormMailScript,$bGotGoBack,$bGotNextForm,$iFormIndex;

    11787. 

  11787.     global  $aFieldOrder,$aCleanedValues,$aRawDataValues,$aAllRawValues;

    11788. 

  11788. 

    11789. 

  11789.     if ($SPECIAL_VALUES["multi_start"] == 1)

    11790. 

  11790.     {

    11791. 

  11791.         if (empty($SPECIAL_VALUES["this_form"]))

    11792. 

  11792.             ErrorWithIgnore("need_this_form",GetMessage(MSG_NEED_THIS_FORM),false,false);

    11793. 

  11793. 

    11794. 

  11794.         $bMultiForm = true;

    11795. 

  11795.             //

    11796. 

  11796.             // Start of multi-page form sequence

    11797. 

  11797.             //

    11798. 

  11798.         $a_list = array();

    11799. 

  11799.         $a_list[0] = array("URL"=>$SPECIAL_VALUES["this_form"],

    11800. 

  11800.                                             "ORDER"=>$aFieldOrder,

    11801. 

  11801.                                             "CLEAN"=>$aCleanedValues,

    11802. 

  11802.                                             "RAWDATA"=>$aRawDataValues,

    11803. 

  11803.                                             "ALLDATA"=>$aAllRawValues,

    11804. 

  11804.                                             "FILES"=>$aFileVars);

    11805. 

  11805.         $iFormIndex = 0;   // zero is the first form, which was just submitted

    11806. 

  11806.         SetSession("FormList",$a_list);

    11807. 

  11807.         SetSession("FormIndex",$iFormIndex);

    11808. 

  11808.             //

    11809. 

  11809.             // this is a fresh session, so remove any remembered values

    11810. 

  11810.             //

    11811. 

  11811.         UnsetSession("FormSavedFiles");

    11812. 

  11812.         UnsetSession("FormKeep");

    11813. 

  11813.     }

    11814. 

  11814.     elseif (IsSetSession("FormList"))

    11815. 

  11815.         $bMultiForm = true;

    11816. 

  11816. 

    11817. 

  11817.     if ($bMultiForm)

    11818. 

  11818.     {

    11819. 

  11819.         if (isset($aServerVars["PHP_SELF"]) &&

    11820. 

  11820.             !empty($aServerVars["PHP_SELF"]) &&

    11821. 

  11821.             isset($aServerVars["SERVER_NAME"]) &&

    11822. 

  11822.             !empty($aServerVars["SERVER_NAME"]))

    11823. 

  11823.         {

    11824. 

  11824.             if (isset($aServerVars["SERVER_PORT"]) &&

    11825. 

  11825.                 $aServerVars["SERVER_PORT"] != 80)

    11826. 

  11826.             {

    11827. 

  11827.                 if ($aServerVars["SERVER_PORT"] == 443)     // SSL port

    11828. 

  11828.                         //

    11829. 

  11829.                         // just use https prefix

    11830. 

  11830.                         //

    11831. 

  11831.                     $sFormMailScript = "https://".$aServerVars["SERVER_NAME"].

    11832. 

  11832.                                                 $aServerVars["PHP_SELF"];

    11833. 

  11833.                 else

    11834. 

  11834.                         //

    11835. 

  11835.                         // use http with port number

    11836. 

  11836.                         //

    11837. 

  11837.                     $sFormMailScript = "http://".$aServerVars["SERVER_NAME"].

    11838. 

  11838.                                         ":".$aServerVars["SERVER_PORT"].

    11839. 

  11839.                                         $aServerVars["PHP_SELF"];

    11840. 

  11840.             }

    11841. 

  11841.             else

    11842. 

  11842.                 $sFormMailScript = "http://".$aServerVars["SERVER_NAME"].

    11843. 

  11843.                                         $aServerVars["PHP_SELF"];

    11844. 

  11844.             $iFormIndex = GetSession("FormIndex");

    11845. 

  11845.         }

    11846. 

  11846.         else

    11847. 

  11847.             Error("no_php_self",GetMessage(MSG_NO_PHP_SELF),false,false);

    11848. 

  11848.     }

    11849. 

  11849. 

    11850. 

  11850.         //

    11851. 

  11851.         // If we're going forward in a multi-page form sequence,

    11852. 

  11852.         // compute a URL to return to the form we're about to display.

    11853. 

  11853.         //

    11854. 

  11854.     if ($bMultiForm && !$bGotGoBack)

    11855. 

  11855.     {

    11856. 

  11856.             //

    11857. 

  11857.             // record the data that was just submitted by the previous form

    11858. 

  11858.             //

    11859. 

  11859.         $iFormIndex = GetSession("FormIndex");

    11860. 

  11860.         $a_list = GetSession("FormList");

    11861. 

  11861.         $a_list[$iFormIndex]["ORDER"] = $aFieldOrder;

    11862. 

  11862.         $a_list[$iFormIndex]["CLEAN"] = $aCleanedValues;

    11863. 

  11863.         $a_list[$iFormIndex]["RAWDATA"] = $aRawDataValues;

    11864. 

  11864.         $a_list[$iFormIndex]["ALLDATA"] = $aAllRawValues;

    11865. 

  11865.         if (count($aFileVars) > 0 && !FILEUPLOADS)

    11866. 

  11866.             SendAlert(GetMessage(MSG_FILE_UPLOAD));

    11867. 

  11867.         elseif (count($aFileVars) > 0 && !SaveAllUploadedFiles($aFileVars))

    11868. 

  11868.             Error("upload_save_failed",GetMessage(MSG_MULTI_UPLOAD),false,false);

    11869. 

  11869.         $a_list[$iFormIndex]["FILES"] = $aFileVars;

    11870. 

  11870.         $iFormIndex++;

    11871. 

  11871.         $s_url = GetReturnLink($sFormMailScript,$iFormIndex);

    11872. 

  11872.         $a_list[$iFormIndex] = array("URL"=>$s_url,

    11873. 

  11873.                                     "FORM"=>$SPECIAL_VALUES["next_form"],

    11874. 

  11874.                                     "ORDER"=>$aFieldOrder,

    11875. 

  11875.                                     "CLEAN"=>$aCleanedValues,

    11876. 

  11876.                                     "RAWDATA"=>$aRawDataValues,

    11877. 

  11877.                                     "ALLDATA"=>$aAllRawValues,

    11878. 

  11878.                                     "FILES"=>$aFileVars);

    11879. 

  11879.         SetSession("FormList",$a_list);

    11880. 

  11880.         SetSession("FormIndex",$iFormIndex);

    11881. 

  11881.         MultiKeep();

    11882. 

  11882.     }

    11883. 

  11883. }

    11884. 

  11884. 

    11885. 

  11885.     //

    11886. 

  11886.     // Check for the MIME Attack

    11887. 

  11887.     //

    11888. 

  11888. function DetectMimeAttack($a_fields,&$s_attack,&$s_info,&$s_user_info)

    11889. 

  11889. {

    11890. 

  11890.         //

    11891. 

  11891.         // if any of the recipient fields contain "MIME-Version" or

    11892. 

  11892.         // "Content-Type" then this is the MIME attack

    11893. 

  11893.         // Now also checks the subject field.

    11894. 

  11894.         //

    11895. 

  11895.     $a_rec_flds = array("recipients","cc","bcc","replyto","subject");

    11896. 

  11896.     foreach ($a_rec_flds as $s_fld)

    11897. 

  11897.         if (isset($a_fields[$s_fld]))

    11898. 

  11898.         {

    11899. 

  11899.                 //

    11900. 

  11900.                 // some of the fields can be arrays

    11901. 

  11901.                 //

    11902. 

  11902.             if (is_array($a_fields[$s_fld]))

    11903. 

  11903.                 $s_data = implode(",",$a_fields[$s_fld]);

    11904. 

  11904.             else

    11905. 

  11905.                 $s_data = $a_fields[$s_fld];

    11906. 

  11906.             $s_data = strtolower($s_data);

    11907. 

  11907.             if (($i_mime = strpos($s_data,"mime-version")) !== false ||

    11908. 

  11908.                 ($i_cont = strpos($s_data,"content-type")) !== false)

    11909. 

  11909.             {

    11910. 

  11910.                 $s_attack = "MIME";

    11911. 

  11911.                 $s_info = GetMessage(MSG_ATTACK_MIME_INFO,

    11912. 

  11912.                             array("FLD"=>$s_fld,

    11913. 

  11913.                                   "CONTENT"=>($i_mime !== false) ?

    11914. 

  11914.                                                 "mime-version" :

    11915. 

  11915.                                                 "content-type"),false);

    11916. 

  11916.                 return (true);

    11917. 

  11917.             }

    11918. 

  11918.         }

    11919. 

  11919.     return (false);

    11920. 

  11920. }

    11921. 

  11921. 

    11922. 

  11922.     //

    11923. 

  11923.     // Strip common language sequences from the data

    11924. 

  11924.     // that might otherwise look like a junk attack.

    11925. 

  11925.     // We replace them with a space so that the stripping

    11926. 

  11926.     // cannot create more junk accidentally.

    11927. 

  11927.     //

    11928. 

  11928. function    AttackDetectionStripLang($s_data)

    11929. 

  11929. {

    11930. 

  11930.     global  $ATTACK_DETECTION_JUNK_LANG_STRIP;

    11931. 

  11931. 

    11932. 

  11932.     foreach ($ATTACK_DETECTION_JUNK_LANG_STRIP as $s_seq)

    11933. 

  11933.         $s_data = str_replace($s_seq," ",$s_data);

    11934. 

  11934.     return ($s_data);

    11935. 

  11935. }

    11936. 

  11936. 

    11937. 

  11937.     //

    11938. 

  11938.     // Find strings of $n_consec characters from the alphabet of $s_alpha

    11939. 

  11939.     // in $s_data.  Return the count of instances found.

    11940. 

  11940.     //

    11941. 

  11941. function    AttackDetectionFindJunk($s_data,$s_alpha,$n_consec,&$a_matches)

    11942. 

  11942. {

    11943. 

  11943.     $s_pat = "/[".preg_quote($s_alpha,"/")."]{"."$n_consec,$n_consec"."}/";

    11944. 

  11944.     if (($n_count = preg_match_all($s_pat,$s_data,$a_matches)) === false)

    11945. 

  11945.     {

    11946. 

  11946.         $n_count = 0;

    11947. 

  11947.         $a_matches = array();

    11948. 

  11948.     }

    11949. 

  11949.     else

    11950. 

  11950.         $a_matches = $a_matches[0];

    11951. 

  11951.     return ($n_count);

    11952. 

  11952. }

    11953. 

  11953. 

    11954. 

  11954.     //

    11955. 

  11955.     // Check for the Junk Attack

    11956. 

  11956.     //

    11957. 

  11957. function DetectJunkAttack($a_fields,&$s_attack,&$s_info,&$s_user_info)

    11958. 

  11958. {

    11959. 

  11959.     global  $ATTACK_DETECTION_JUNK_IGNORE_FIELDS;

    11960. 

  11960. 

    11961. 

  11961.         //

    11962. 

  11962.         // If any field contains junk data, trigger detection.

    11963. 

  11963.         //

    11964. 

  11964.     $n_count = 0;

    11965. 

  11965.     $a_matches = array();

    11966. 

  11966.     $a_user_matches = array();

    11967. 

  11967.     foreach ($a_fields as $s_fld=>$m_value)

    11968. 

  11968.     {

    11969. 

  11969.         if (IsSpecialField($s_fld) || IsSpecialMultiField($s_fld))

    11970. 

  11970.         {

    11971. 

  11971.                 //

    11972. 

  11972.                 // Skip special fields because they don't contain

    11973. 

  11973.                 // normal user input.

    11974. 

  11974.                 // But, some special fields do contain normal user

    11975. 

  11975.                 // input, so we don't skip them.

    11976. 

  11976.                 //

    11977. 

  11977.             $b_skip = true;

    11978. 

  11978.             switch ($s_fld)

    11979. 

  11979.             {

    11980. 

  11980.             case "realname":

    11981. 

  11981.             case "subject":

    11982. 

  11982.                     $b_skip = false;

    11983. 

  11983.                     break;

    11984. 

  11984.             }

    11985. 

  11985.             if ($b_skip)

    11986. 

  11986.                 continue;

    11987. 

  11987.         }

    11988. 

  11988.                 //

    11989. 

  11989.                 // Ignore fields that are specified to contain

    11990. 

  11990.                 // technical information.

    11991. 

  11991.                 //

    11992. 

  11992.         if (in_array($s_fld,$ATTACK_DETECTION_JUNK_IGNORE_FIELDS,true))

    11993. 

  11993.             continue;

    11994. 

  11994.         if (isset($m_value) && !FieldManager::IsEmpty($m_value))

    11995. 

  11995.         {

    11996. 

  11996.             if (!is_array($m_value))

    11997. 

  11997.                 $m_value = array($m_value);

    11998. 

  11998.             foreach ($m_value as $s_data)

    11999. 

  11999.             {

    12000. 

  12000.                 $s_orig_data = $s_data = strtolower($s_data);

    12001. 

  12001.                     //

    12002. 

  12002.                     // Strip out sequences that might be common to

    12003. 

  12003.                     // the user's language.

    12004. 

  12004.                     // For example, in English, there are a lot of common

    12005. 

  12005.                     // words that can easily be protected from our

    12006. 

  12006.                     // tests. For example, "thousandths" has 5 consecutive consonants

    12007. 

  12007.                     // but is a reasonable word.

    12008. 

  12008.                     // Similarly, "queue" has 4 consecutive vowels.

    12009. 

  12009.                     //

    12010. 

  12010.                 $s_data = AttackDetectionStripLang($s_data);

    12011. 

  12011.                     //

    12012. 

  12012.                     // Look for strings of too many vowels or too many consonants.

    12013. 

  12013.                     // For safety, we must detect more than one instance, because there

    12014. 

  12014.                     // are a lot of normal words that may be caught by this test.

    12015. 

  12015.                     // The number of instances is controlled by configuration.

    12016. 

  12016.                     //

    12017. 

  12017.                 $n_match = AttackDetectionFindJunk($s_data,ATTACK_DETECTION_JUNK_CONSONANTS,

    12018. 

  12018.                                                 ATTACK_DETECTION_JUNK_CONSEC_CONSONANTS,

    12019. 

  12019.                                                 $a_match_cons);

    12020. 

  12020.                 if ($n_match > 0)

    12021. 

  12021.                     $a_user_matches[] = $s_orig_data;

    12022. 

  12022.                 $n_count += $n_match;

    12023. 

  12023.                 $n_match = AttackDetectionFindJunk($s_data,ATTACK_DETECTION_JUNK_VOWELS,

    12024. 

  12024.                                                 ATTACK_DETECTION_JUNK_CONSEC_VOWELS,

    12025. 

  12025.                                                 $a_match_vow);

    12026. 

  12026.                 if ($n_match > 0)

    12027. 

  12027.                     $a_user_matches[] = $s_orig_data;

    12028. 

  12028.                 $n_count += $n_match;

    12029. 

  12029.                 if ($n_count >= ATTACK_DETECTION_JUNK_TRIGGER)

    12030. 

  12030.                 {

    12031. 

  12031.                     $a_matches = array_merge($a_matches,$a_match_cons,$a_match_vow);

    12032. 

  12032.                     $s_user_info = GetMessage(MSG_USER_ATTACK_JUNK,

    12033. 

  12033.                                         array("INPUT"=>implode(", ",$a_user_matches)),false);

    12034. 

  12034.                     $s_attack = "JUNK";

    12035. 

  12035.                     $s_info = GetMessage(MSG_ATTACK_JUNK_INFO,

    12036. 

  12036.                                 array("FLD"=>$s_fld,

    12037. 

  12037.                                       "JUNK"=>implode(" ",$a_matches)),false);

    12038. 

  12038.                     return (true);

    12039. 

  12039.                 }

    12040. 

  12040.             }

    12041. 

  12041.         }

    12042. 

  12042.     }

    12043. 

  12043.     return (false);

    12044. 

  12044. }

    12045. 

  12045. 

    12046. 

  12046.     //

    12047. 

  12047.     // Check for the duplicate data attack

    12048. 

  12048.     //

    12049. 

  12049. function DetectDupAttack($a_fields,&$s_attack,&$s_info,&$s_user_info)

    12050. 

  12050. {

    12051. 

  12051.         //

    12052. 

  12052.         // if any of the configured fields contain duplicate data,

    12053. 

  12053.         // then this lame attack has been detected

    12054. 

  12054.         //

    12055. 

  12055.     global  $ATTACK_DETECTION_DUPS;

    12056. 

  12056. 

    12057. 

  12057.     $a_data_map = array();

    12058. 

  12058.     foreach ($ATTACK_DETECTION_DUPS as $s_fld)

    12059. 

  12059.         if (isset($a_fields[$s_fld]) &&

    12060. 

  12060.             is_scalar($a_fields[$s_fld]) &&    // can only work with string data

    12061. 

  12061.             !empty($a_fields[$s_fld]))

    12062. 

  12062.         {

    12063. 

  12063.             $s_data = (string) $a_fields[$s_fld];

    12064. 

  12064.             if (isset($a_data_map[$s_data]))

    12065. 

  12065.             {

    12066. 

  12066.                     //

    12067. 

  12067.                     // duplicate found!

    12068. 

  12068.                     //

    12069. 

  12069.                 $s_attack = "Duplicate Fields";

    12070. 

  12070.                 $s_info = GetMessage(MSG_ATTACK_DUP_INFO,

    12071. 

  12071.                             array("FLD1"=>$a_data_map[$s_data],

    12072. 

  12072.                                   "FLD2"=>$s_fld),false);

    12073. 

  12073.                 $s_user_info = GetMessage(MSG_USER_ATTACK_DUP,array(),false);

    12074. 

  12074.                 return (true);

    12075. 

  12075.             }

    12076. 

  12076.             $a_data_map[$s_data] = $s_fld;

    12077. 

  12077.         }

    12078. 

  12078.     return (false);

    12079. 

  12079. }

    12080. 

  12080. 

    12081. 

  12081.     //

    12082. 

  12082.     // Check for the email addresses in specials attack

    12083. 

  12083.     //

    12084. 

  12084. function DetectSpecialsAttack($a_fields,&$s_attack,&$s_info,&$s_user_info)

    12085. 

  12085. {

    12086. 

  12086.     global  $ATTACK_DETECTION_SPECIALS_ONLY_EMAIL,

    12087. 

  12087.             $ATTACK_DETECTION_SPECIALS_ANY_EMAIL;

    12088. 

  12088. 

    12089. 

  12089.         //

    12090. 

  12090.         // look for email addresses in whole fields

    12091. 

  12091.         //

    12092. 

  12092.     foreach ($ATTACK_DETECTION_SPECIALS_ONLY_EMAIL as $s_fld)

    12093. 

  12093.     {

    12094. 

  12094.         if (isset($a_fields[$s_fld]) &&

    12095. 

  12095.             is_scalar($a_fields[$s_fld]) &&    // can only work with string data

    12096. 

  12096.             !empty($a_fields[$s_fld]))

    12097. 

  12097.         {

    12098. 

  12098.             $s_data = $a_fields[$s_fld];

    12099. 

  12099.             if (preg_match("/^\b[-a-z0-9._%]+@[-.%_a-z0-9]+\.[a-z]{2,9}\b$/i",

    12100. 

  12100.                             $s_data) === 1)

    12101. 

  12101.             {

    12102. 

  12102.                     //

    12103. 

  12103.                     // email address found in wrong field

    12104. 

  12104.                     //

    12105. 

  12105.                 $s_attack = "Special Fields Only";

    12106. 

  12106.                 $s_info = GetMessage(MSG_ATTACK_SPEC_INFO,

    12107. 

  12107.                             array("FLD"=>$s_fld),false);

    12108. 

  12108.                 return (true);

    12109. 

  12109.             }

    12110. 

  12110.         }

    12111. 

  12111.     }

    12112. 

  12112.         //

    12113. 

  12113.         // look for email addresses in any part of fields

    12114. 

  12114.         //

    12115. 

  12115.     foreach ($ATTACK_DETECTION_SPECIALS_ANY_EMAIL as $s_fld)

    12116. 

  12116.     {

    12117. 

  12117.         if (isset($a_fields[$s_fld]) &&

    12118. 

  12118.             is_scalar($a_fields[$s_fld]) &&    // can only work with string data

    12119. 

  12119.             !empty($a_fields[$s_fld]))

    12120. 

  12120.         {

    12121. 

  12121.             $s_data = $a_fields[$s_fld];

    12122. 

  12122.             if (preg_match("/\b[-a-z0-9._%]+@[-.%_a-z0-9]+\.[a-z]{2,9}\b/i",

    12123. 

  12123.                             $s_data) > 0)

    12124. 

  12124.             {

    12125. 

  12125.                     //

    12126. 

  12126.                     // email address found in wrong field

    12127. 

  12127.                     //

    12128. 

  12128.                 $s_attack = "Special Fields Any";

    12129. 

  12129.                 $s_info = GetMessage(MSG_ATTACK_SPEC_INFO,

    12130. 

  12130.                             array("FLD"=>$s_fld),false);

    12131. 

  12131.                 return (true);

    12132. 

  12132.             }

    12133. 

  12133.         }

    12134. 

  12134.     }

    12135. 

  12135.     return (false);

    12136. 

  12136. }

    12137. 

  12137. 

    12138. 

  12138.     //

    12139. 

  12139.     // Check for "many URLs in a field" and "many fields with URLs" attacks

    12140. 

  12140.     //

    12141. 

  12141. function DetectManyURLsAttack($a_fields,&$s_attack,&$s_info,&$s_user_info)

    12142. 

  12142. {

    12143. 

  12143.     global      $ATTACK_DETECTION_URL_PATTERNS;

    12144. 

  12144. 

    12145. 

  12145.     $a_fld_names = array();

    12146. 

  12146.         //

    12147. 

  12147.         // actual URL link patterns

    12148. 

  12148.         //

    12149. 

  12149.     $s_srch = '((\bhttps{0,1}:\/\/|<\s*a\s+href=["'."'".']{0,1})[-a-z0-9.]+\b)';

    12150. 

  12150. 

    12151. 

  12151.         //

    12152. 

  12152.         // now add configurable patterns

    12153. 

  12153.         //

    12154. 

  12154.     if (!empty($ATTACK_DETECTION_URL_PATTERNS) &&

    12155. 

  12155.         is_array($ATTACK_DETECTION_URL_PATTERNS))

    12156. 

  12156.     {

    12157. 

  12157.             //

    12158. 

  12158.             // escape / characters and build up a string

    12159. 

  12159.             // of alternate patterns

    12160. 

  12160.             //

    12161. 

  12161.         foreach ($ATTACK_DETECTION_URL_PATTERNS as $s_pat)

    12162. 

  12162.         {

    12163. 

  12163.             if ($s_pat == "")

    12164. 

  12164.                 continue;

    12165. 

  12165.             $s_srch .= "|".str_replace('/','\/',$s_pat);

    12166. 

  12166.         }

    12167. 

  12167.     }

    12168. 

  12168. 

    12169. 

  12169.     foreach ($a_fields as $s_fld=>$s_data)

    12170. 

  12170.     {

    12171. 

  12171.         if (IsSpecialField($s_fld) || IsSpecialMultiField($s_fld))

    12172. 

  12172.                 //

    12173. 

  12173.                 // skip special fields because some are supposed to

    12174. 

  12174.                 // have URLs in them

    12175. 

  12175.                 //

    12176. 

  12176.             continue;

    12177. 

  12177.         if (isset($s_data) &&

    12178. 

  12178.             is_scalar($s_data) &&    // can only work with string data

    12179. 

  12179.             !empty($s_data))

    12180. 

  12180.         {

    12181. 

  12181.             $n_match = preg_match_all("/$s_srch/msi",$s_data,$a_matches);

    12182. 

  12182.             if (!is_int($n_match))

    12183. 

  12183.                 $n_match = 0;

    12184. 

  12184.             /*

    12185. 

  12185.              * debugging code....

    12186. 

  12186.              if ($n_match > 0)

    12187. 

  12187.                 echo "Pattern is '".htmlentities($s_srch)."' with '".

    12188. 

  12188.                     htmlentities($s_data)."' field '$s_fld', matched=$n_match<br />";

    12189. 

  12189.              */

    12190. 

  12190.             if (ATTACK_DETECTION_MANY_URLS > 0)

    12191. 

  12191.                 if ($n_match >= ATTACK_DETECTION_MANY_URLS)

    12192. 

  12192.                 {

    12193. 

  12193.                     $s_attack = "Many URLS in a field";

    12194. 

  12194.                     $s_info = GetMessage(MSG_ATTACK_MANYURL_INFO,

    12195. 

  12195.                                 array("FLD"=>$s_fld,"NUM"=>($n_match)),false);

    12196. 

  12196.                     $s_user_info = GetMessage(MSG_USER_ATTACK_MANY_URLS,array(),false);

    12197. 

  12197.                     return (true);

    12198. 

  12198.                 }

    12199. 

  12199.             if ($n_match > 0)

    12200. 

  12200.                 $a_fld_names[] = $s_fld;

    12201. 

  12201.         }

    12202. 

  12202.     }

    12203. 

  12203.     if (ATTACK_DETECTION_MANY_URL_FIELDS > 0)

    12204. 

  12204.         if (count($a_fld_names) >= ATTACK_DETECTION_MANY_URL_FIELDS)

    12205. 

  12205.         {

    12206. 

  12206.             $s_attack = "Many fields with URLs";

    12207. 

  12207.             $s_info = GetMessage(MSG_ATTACK_MANYFIELDS_INFO,

    12208. 

  12208.                         array("FLDS"=>implode(",",$a_fld_names),

    12209. 

  12209.                                 "NUM"=>(count($a_fld_names))),false);

    12210. 

  12210.             $s_user_info = GetMessage(MSG_USER_ATTACK_MANY_URL_FIELDS,array(),false);

    12211. 

  12211.             return (true);

    12212. 

  12212.         }

    12213. 

  12213.     return (false);

    12214. 

  12214. }

    12215. 

  12215. 

    12216. 

  12216. function    IsAjax()

    12217. 

  12217. {

    12218. 

  12218.     global  $SPECIAL_VALUES,$aFormVars,$aGetVars;

    12219. 

  12219. 

    12220. 

  12220.     //

    12221. 

  12221.     // this may be called too early to have SPECIAL_VALUES loaded,

    12222. 

  12222.     // so we check the submitted form vars too.

    12223. 

  12223.     //

    12224. 

  12224.     if ($SPECIAL_VALUES["fmmode"] == "ajax")

    12225. 

  12225.         return (true);

    12226. 

  12226.     if (isset($aFormVars["fmmode"]))

    12227. 

  12227.         return ($aFormVars["fmmode"] == "ajax");

    12228. 

  12228.     if (isset($aGetVars["fmmode"]))

    12229. 

  12229.         return ($aGetVars["fmmode"] == "ajax");

    12230. 

  12230.     return (false);

    12231. 

  12231. }

    12232. 

  12232. 

    12233. 

  12233.     //

    12234. 

  12234.     // Detect annoying attacks and prevent them from sending spurious

    12235. 

  12235.     // alert messages.

    12236. 

  12236.     //

    12237. 

  12237. function DetectAttacks($a_fields)

    12238. 

  12238. {

    12239. 

  12239.     global      $ATTACK_DETECTION_DUPS,$ATTACK_DETECTION_REVERSE_CAPTCHA;

    12240. 

  12240. 

    12241. 

  12241.     $s_info = $s_attack = "";

    12242. 

  12242.     $b_attacked = false;

    12243. 

  12243.     $s_user_info = "";

    12244. 

  12244.     if (ATTACK_DETECTION_MIME)

    12245. 

  12245.         if (DetectMimeAttack($a_fields,$s_attack,$s_info,$s_user_info))

    12246. 

  12246.             $b_attacked = true;

    12247. 

  12247.     if (!$b_attacked && !empty($ATTACK_DETECTION_DUPS))

    12248. 

  12248.         if (DetectDupAttack($a_fields,$s_attack,$s_info,$s_user_info))

    12249. 

  12249.             $b_attacked = true;

    12250. 

  12250.     if (!$b_attacked && ATTACK_DETECTION_SPECIALS)

    12251. 

  12251.         if (DetectSpecialsAttack($a_fields,$s_attack,$s_info,$s_user_info))

    12252. 

  12252.             $b_attacked = true;

    12253. 

  12253.     if (!$b_attacked && (ATTACK_DETECTION_MANY_URLS ||

    12254. 

  12254.                         ATTACK_DETECTION_MANY_URL_FIELDS))

    12255. 

  12255.         if (DetectManyURLsAttack($a_fields,$s_attack,$s_info,$s_user_info))

    12256. 

  12256.             $b_attacked = true;

    12257. 

  12257.     if (ATTACK_DETECTION_JUNK)

    12258. 

  12258.         if (DetectJunkAttack($a_fields,$s_attack,$s_info,$s_user_info))

    12259. 

  12259.             $b_attacked = true;

    12260. 

  12260. 

    12261. 

  12261.     if (!$b_attacked && !empty($ATTACK_DETECTION_REVERSE_CAPTCHA))

    12262. 

  12262.             if (DetectRevCaptchaAttack($ATTACK_DETECTION_REVERSE_CAPTCHA,$a_fields,$s_attack,$s_info,$s_user_info))

    12263. 

  12263.                 $b_attacked = true;

    12264. 

  12264. 

    12265. 

  12265.     if ($b_attacked)

    12266. 

  12266.     {

    12267. 

  12267.         if (function_exists('FMHookAttacked'))

    12268. 

  12268.             FMHookAttacked('');     /* in the future, pass the type of attack */

    12269. 

  12269.         if (ALERT_ON_ATTACK_DETECTION)

    12270. 

  12270.             SendAlert(GetMessage(MSG_ATTACK_DETECTED,

    12271. 

  12271.                     array("ATTACK"=>$s_attack,

    12272. 

  12272.                           "INFO"=>$s_info,)),

    12273. 

  12273.                         false);

    12274. 

  12274.         if (!IsAjax() && ATTACK_DETECTION_URL !== "")

    12275. 

  12275.             Redirect(ATTACK_DETECTION_URL,GetMessage(MSG_FORM_ERROR));

    12276. 

  12276.         else

    12277. 

  12277.         {

    12278. 

  12278.             global  $SERVER;

    12279. 

  12279. 

    12280. 

  12280.             CreatePage(GetMessage(MSG_ATTACK_PAGE,array("SERVER"=>$SERVER,"USERINFO"=>$s_user_info)),

    12281. 

  12281.                         GetMessage(MSG_FORM_ERROR));

    12282. 

  12282.         }

    12283. 

  12283.         exit;

    12284. 

  12284.     }

    12285. 

  12285. }

    12286. 

  12286. 

    12287. 

  12287.     //

    12288. 

  12288.     // Implement reverse captcha.  At least two fields must be provided.

    12289. 

  12289.     // At least one of the fields should have a non-empty value.

    12290. 

  12290.     //

    12291. 

  12291. function    DetectRevCaptchaAttack($a_revcap_spec,$a_form_data,&$s_attack,&$s_info,&$s_user_info)

    12292. 

  12292. {

    12293. 

  12293.     global      $bReverseCaptchaCompleted;

    12294. 

  12294. 

    12295. 

  12295.     if (count($a_revcap_spec) < 2)

    12296. 

  12296.     {

    12297. 

  12297.         SendAlert(GetMessage(MSG_REV_CAP));

    12298. 

  12298.         return (false);

    12299. 

  12299.     }

    12300. 

  12300.         //

    12301. 

  12301.         // check the reverse captcha fields

    12302. 

  12302.         //

    12303. 

  12303.     $n_empty = $n_non_empty = 0;

    12304. 

  12304.     $b_attacked = false;

    12305. 

  12305.     $s_info = "";

    12306. 

  12306.     foreach ($a_revcap_spec as $s_fld_name=>$s_value)

    12307. 

  12307.     {

    12308. 

  12308.         if ($s_value === "")

    12309. 

  12309.         {

    12310. 

  12310.             $n_empty++;

    12311. 

  12311.             if (isset($a_form_data[$s_fld_name]) &&

    12312. 

  12312.                     $a_form_data[$s_fld_name] !== "")

    12313. 

  12313.             {

    12314. 

  12314.                 $b_attacked = true;

    12315. 

  12315.                 $s_info .= "\n".GetMessage(MSG_ATTACK_REV_CAP_INFO,

    12316. 

  12316.                             array("FLD"=>$s_fld_name,

    12317. 

  12317.                                     "CONTENT"=>$a_form_data[$s_fld_name]),false);

    12318. 

  12318.             }

    12319. 

  12319.         }

    12320. 

  12320.         else

    12321. 

  12321.         {

    12322. 

  12322.             $n_non_empty++;

    12323. 

  12323.             if (!isset($a_form_data[$s_fld_name]) ||

    12324. 

  12324.                     $a_form_data[$s_fld_name] !== $s_value)

    12325. 

  12325.             {

    12326. 

  12326.                 $b_attacked = true;

    12327. 

  12327.                 $s_info .= "\n".GetMessage(MSG_ATTACK_REV_CAP_INFO,

    12328. 

  12328.                             array("FLD"=>$s_fld_name,

    12329. 

  12329.                                     "CONTENT"=>

    12330. 

  12330.                                         isset($a_form_data[$s_fld_name]) ?

    12331. 

  12331.                                             $a_form_data[$s_fld_name] :

    12332. 

  12332.                                             ""),false);

    12333. 

  12333.             }

    12334. 

  12334.         }

    12335. 

  12335.     }

    12336. 

  12336.         //

    12337. 

  12337.         // check that the rev captcha specification is correct:

    12338. 

  12338.         //      at least two fields, at least one empty

    12339. 

  12339.         //      and at least one non-empty

    12340. 

  12340.         //

    12341. 

  12341.     if ($n_empty + $n_non_empty < 2 ||

    12342. 

  12342.         $n_empty == 0 || $n_non_empty == 0)

    12343. 

  12343.     {

    12344. 

  12344.         SendAlert(GetMessage(MSG_REV_CAP));

    12345. 

  12345.         return (false);

    12346. 

  12346.     }

    12347. 

  12347.     if ($b_attacked)

    12348. 

  12348.     {

    12349. 

  12349.         $s_attack = "Reverse Captcha";

    12350. 

  12350.         $s_user_info = GetMessage(MSG_USER_ATTACK_REV_CAP,array(),false);

    12351. 

  12351.     }

    12352. 

  12352.     $bReverseCaptchaCompleted = !$b_attacked;

    12353. 

  12353.     //FMDebug("RevCaptcha done: ".($bReverseCaptchaCompleted ? "success" : "failure"));

    12354. 

  12354.     return ($b_attacked);

    12355. 

  12355. }

    12356. 

  12356. 

    12357. 

  12357.     //

    12358. 

  12358.     // Check whether a form submission is allowed based on any Captcha provided

    12359. 

  12359.     //

    12360. 

  12360. function    CheckCaptchaSubmit()

    12361. 

  12361. {

    12362. 

  12362.     global  $SPECIAL_VALUES,$reCaptchaProcessor;

    12363. 

  12363. 

    12364. 

  12364.     if ($SPECIAL_VALUES["imgverify"] !== "")

    12365. 

  12365.     {

    12366. 

  12366.             //

    12367. 

  12367.             // implement reCaptcha

    12368. 

  12368.             //

    12369. 

  12369.         if (isset($reCaptchaProcessor))

    12370. 

  12370.         {

    12371. 

  12371.             if (!$reCaptchaProcessor->Check($SPECIAL_VALUES["imgverify"],$SPECIAL_VALUES,$s_error))

    12372. 

  12372.                 UserError("recaptcha",GetMessage(MSG_RECAPTCHA_MATCH,array("ERR"=>$s_error)));

    12373. 

  12373.         }

    12374. 

  12374.             //

    12375. 

  12375.             // implement other CAPTCHA

    12376. 

  12376.             //

    12377. 

  12377.         else

    12378. 

  12378.         {

    12379. 

  12379.                 //

    12380. 

  12380.                 // VerifyImgString is from Tectite's simple verifyimg.php CAPTCHA

    12381. 

  12381.                 // turing_string is from Captcha Creator

    12382. 

  12382.                 //

    12383. 

  12383.             if (!IsSetSession("VerifyImgString") &&

    12384. 

  12384.                 !IsSetSession("turing_string"))

    12385. 

  12385.                 ErrorWithIgnore("verify_failed",GetMessage(MSG_VERIFY_MISSING),false);

    12386. 

  12386.                 //

    12387. 

  12387.                 // the user's entry must match the value in the session; allow

    12388. 

  12388.                 // spaces in the user's input

    12389. 

  12389.                 //

    12390. 

  12390.             if (IsSetSession("VerifyImgString"))

    12391. 

  12391.             {

    12392. 

  12392.                 if (strtoupper(str_replace(" ","",$SPECIAL_VALUES["imgverify"])) !==

    12393. 

  12393.                             strtoupper(GetSession("VerifyImgString")))

    12394. 

  12394.                     UserError("img_verify",GetMessage(MSG_VERIFY_MATCH));

    12395. 

  12395.             }

    12396. 

  12396.             else

    12397. 

  12397.             {

    12398. 

  12398.                 if (strtoupper(str_replace(" ","",$SPECIAL_VALUES["imgverify"])) !==

    12399. 

  12399.                             strtoupper(GetSession("turing_string")))

    12400. 

  12400.                     UserError("img_verify",GetMessage(MSG_VERIFY_MATCH)/*,

    12401. 

  12401.                                 "imgverify='".$SPECIAL_VALUES["imgverify"]."' ".

    12402. 

  12402.                                 "turing_string='".GetSession("turing_string")."'"*/);

    12403. 

  12403.             }

    12404. 

  12404.         }

    12405. 

  12405.     }

    12406. 

  12406. }

    12407. 

  12407. 

    12408. 

  12408. /*

    12409. 

  12409.  * Class:       AutoResponder

    12410. 

  12410.  * Description:     

    12411. 

  12411.  *  Implements the auto responding feature of FormMail.

    12412. 

  12412.  *  The object must only be created after special fields have been

    12413. 

  12413.  *  processed.

    12414. 

  12414.  */

    12415. 

  12415. class   AutoResponder

    12416. 

  12416. {

    12417. 

  12417.     var     $_bRequested;       // true if requested by the form

    12418. 

  12418.     var     $_sTo;              // to-address for auto response

    12419. 

  12419.     var     $_sSubject;         // subject for auto response

    12420. 

  12420. 

    12421. 

  12421.     var     $_iNone = 0;        // must be zero - initializes iType and iCaptchaType

    12422. 

  12422. 

    12423. 

  12423.     var     $_iCaptchaType;     // type of CAPTCHA that's been successfully processed

    12424. 

  12424.     var     $_bCaptchaOK;       // true if CAPTCHA processing is OK, otherwise false

    12425. 

  12425. 

    12426. 

  12426.         //

    12427. 

  12427.         // values of _iCaptchaType

    12428. 

  12428.         //

    12429. 

  12429.     var     $_iFull = 1;        // full captcha

    12430. 

  12430.     var     $_iRev = 2;         // reverse captcha

    12431. 

  12431. 

    12432. 

  12432.     var     $_iType;            // type of autoresponse (template or plain)

    12433. 

  12433. 

    12434. 

  12434.         //

    12435. 

  12435.         // values of _iType

    12436. 

  12436.         //

    12437. 

  12437.     var     $_iSendTemplate = 1;    // send a template

    12438. 

  12438.     var     $_iSendPlain = 2;       // send a plain file

    12439. 

  12439. 

    12440. 

  12440.     /*

    12441. 

  12441.      * Method:      AutoResponder ctor

    12442. 

  12442.      * Parameters:  void

    12443. 

  12443.      * Returns:     n/a 

    12444. 

  12444.      * Description: 

    12445. 

  12445.      *  Constructs the object.

    12446. 

  12446.      */

    12447. 

  12447.     function    AutoResponder()

    12448. 

  12448.     {

    12449. 

  12449.         global  $SPECIAL_VALUES;

    12450. 

  12450. 

    12451. 

  12451.         $this->_bCaptchaOK = $this->_bRequested = false;

    12452. 

  12452.         $this->_sTo = "";

    12453. 

  12453.         $this->_sSubject = "";

    12454. 

  12454.         $this->_iType = $this->_iNone;

    12455. 

  12455.         $this->_iCaptchaType = $this->_iNone;

    12456. 

  12456. 

    12457. 

  12457.             //

    12458. 

  12458.             // An autoreponse is sometimes optional in the sense the user

    12459. 

  12459.             // can choose whether they want it.

    12460. 

  12460.             // It can also be mandatory, and enforced by the form owner.

    12461. 

  12461.             // Here are the rules:

    12462. 

  12462.             //  1.  If there is no return email address (email field), no autoresponse.

    12463. 

  12463.             //      In this case, if autoresponse has been requested by the form, send

    12464. 

  12464.             //      an alert message to the form owner, but otherwise ignore the problem

    12465. 

  12465.             //      (it's optional).

    12466. 

  12466.             //  2.  If no autoresponse has been requested by the form, skip.

    12467. 

  12467.             //  3.  If HTMLTemplate or PlainTemplate is set:

    12468. 

  12468.             //      3a. If full CAPTCHA has been performed, send autoresponse.

    12469. 

  12469.             //      3b  If no full CAPTCHA has been performed, no autoresponse.

    12470. 

  12470.             //  4.  If HTMLTemplate and PlainTemplate are *not* set and either

    12471. 

  12471.             //      PlainFile or HTMLFile is set:

    12472. 

  12472.             //      4a. If full CAPTCHA has been performed, send autoresponse.

    12473. 

  12473.             //      4b. If Reverse CAPTCHA has been performed, send autoresponse.

    12474. 

  12474.             //      4c. Otherwise, no autoresponse.

    12475. 

  12475.             //  5.  If full CAPTCHA is attempted but fails (e.g. wrong input), display

    12476. 

  12476.             //      error.

    12477. 

  12477.             //

    12478. 

  12478.             // The form owner can enforce autoresponse by making "email" required,

    12479. 

  12479.             // and making "arverify" or "recaptcha_response_field" required (for templates)

    12480. 

  12480.             // or by ensuring Reverse CAPTCHA is performed (for PlainFile or HTMLFile).

    12481. 

  12481.             //

    12482. 

  12482.         if (IsAROptionSet('HTMLTemplate') ||

    12483. 

  12483.             IsAROptionSet('PlainTemplate'))

    12484. 

  12484.             $this->_iType = $this->_iSendTemplate;

    12485. 

  12485.         if (IsAROptionSet('PlainFile') ||

    12486. 

  12486.             IsAROptionSet('HTMLFile'))

    12487. 

  12487.             $this->_iType = $this->_iSendPlain;

    12488. 

  12488.         if ($this->_iType)

    12489. 

  12489.         {

    12490. 

  12490.                 //

    12491. 

  12491.                 // the form has requested autoresponse....

    12492. 

  12492.                 // we need an email address to send to

    12493. 

  12493.                 //

    12494. 

  12494.             if (!isset($SPECIAL_VALUES["email"]) || empty($SPECIAL_VALUES["email"]))

    12495. 

  12495.                 SendAlert(GetMessage(MSG_ARESP_EMAIL));

    12496. 

  12496.             else

    12497. 

  12497.             {

    12498. 

  12498.                 $this->_bRequested = true;

    12499. 

  12499.                 $this->_sTo = $SPECIAL_VALUES["email"];

    12500. 

  12500.                 if (IsAROptionSet('Subject'))

    12501. 

  12501.                     $this->_sSubject = GetAROption('Subject');

    12502. 

  12502.                 else

    12503. 

  12503.                     $this->_sSubject = GetMessage(MSG_ARESP_SUBJ,array(),false);

    12504. 

  12504.             }

    12505. 

  12505.         }

    12506. 

  12506.     }

    12507. 

  12507. 

    12508. 

  12508.     /*

    12509. 

  12509.      * Method:      AutoResponder::IsRequested

    12510. 

  12510.      * Parameters:  void

    12511. 

  12511.      * Returns:     bool    true if autoresponding has been requested

    12512. 

  12512.      * Description: 

    12513. 

  12513.      *  Determines if autoresponding has been requested by the HTML.  

    12514. 

  12514.      */

    12515. 

  12515.     function    IsRequested()

    12516. 

  12516.     {

    12517. 

  12517.         return ($this->_bRequested);

    12518. 

  12518.     }

    12519. 

  12519. 

    12520. 

  12520.     /*

    12521. 

  12521.      * Method:      AutoResponder::Process

    12522. 

  12522.      * Parameters:  $b_check_only   if true, perform checks but do not send

    12523. 

  12523.      * Returns:     void

    12524. 

  12524.      * Description: 

    12525. 

  12525.      *  Processes the autorespond.

    12526. 

  12526.      */

    12527. 

  12527.     function    Process($b_check_only = false)

    12528. 

  12528.     {

    12529. 

  12529.         global  $SPECIAL_VALUES;

    12530. 

  12530. 

    12531. 

  12531.         FMDebug("AutoResponder::Process: check=".($b_check_only ? "Y" : "N"));

    12532. 

  12532.         if ($this->IsRequested())

    12533. 

  12533.         {

    12534. 

  12534.             FMDebug("AutoResponder::Process: requested");

    12535. 

  12535.                 //

    12536. 

  12536.                 // verify CAPTCHA or that Reverse CAPTCHA has been completed

    12537. 

  12537.                 // (unless we've already done that)

    12538. 

  12538.                 //

    12539. 

  12539.             $this->_CheckCaptcha();

    12540. 

  12540.             if (!$b_check_only && $this->_bCaptchaOK)

    12541. 

  12541.             {

    12542. 

  12542.                 FMDebug("AutoResponder::Process: proceeding, type=".$this->_iType);

    12543. 

  12543.                     //

    12544. 

  12544.                     // for a template, full CAPTCHA must have been processed

    12545. 

  12545.                     //

    12546. 

  12546.                 if ($this->_iType == $this->_iSendTemplate)

    12547. 

  12547.                 {

    12548. 

  12548.                     if ($this->_iCaptchaType == $this->_iFull)

    12549. 

  12549.                         $this->_Send(true);

    12550. 

  12550.                 }

    12551. 

  12551.                     //

    12552. 

  12552.                     // for a plain file, reverse CAPTCHA is sufficient, any CAPTCHA is OK

    12553. 

  12553.                     //

    12554. 

  12554.                 elseif ($this->_iType == $this->_iSendPlain)

    12555. 

  12555.                     if ($this->_iCaptchaType)

    12556. 

  12556.                         $this->_Send(false);

    12557. 

  12557.             }

    12558. 

  12558.         }

    12559. 

  12559.     }

    12560. 

  12560. 

    12561. 

  12561.     /*

    12562. 

  12562.      * Method:      AutoResponder::_CheckCaptcha

    12563. 

  12563.      * Parameters:  void

    12564. 

  12564.      * Returns:     void 

    12565. 

  12565.      * Description: 

    12566. 

  12566.      *  Checks the type of CAPTCHA that has been processed.

    12567. 

  12567.      *  This method should only be called if autoresponse has been requested

    12568. 

  12568.      *  by the form (i.e. IsRequested returns true).

    12569. 

  12569.      */

    12570. 

  12570.     function    _CheckCaptcha()

    12571. 

  12571.     {

    12572. 

  12572.         global  $SPECIAL_VALUES,$bReverseCaptchaCompleted,$ATTACK_DETECTION_REVERSE_CAPTCHA;

    12573. 

  12573.         global  $reCaptchaProcessor;

    12574. 

  12574. 

    12575. 

  12575.             //

    12576. 

  12576.             // only check for CAPTCHA once

    12577. 

  12577.             //

    12578. 

  12578.         if (!$this->_iCaptchaType)

    12579. 

  12579.         {

    12580. 

  12580.                 //

    12581. 

  12581.                 // check for full CAPTCHA attempt

    12582. 

  12582.                 // first, check for reCaptcha

    12583. 

  12583.                 //

    12584. 

  12584.             if (isset($reCaptchaProcessor) && $SPECIAL_VALUES["arverify"] !== "")

    12585. 

  12585.             {

    12586. 

  12586.                 $this->_iCaptchaType = $this->_iFull;

    12587. 

  12587.                 if ($reCaptchaProcessor->Check($SPECIAL_VALUES["arverify"],$SPECIAL_VALUES,$s_error))

    12588. 

  12588.                     $this->_bCaptchaOK = true;

    12589. 

  12589.                 else

    12590. 

  12590.                 {

    12591. 

  12591.                     $this->_bCaptchaOK = false;

    12592. 

  12592.                         //

    12593. 

  12593.                         // report the error

    12594. 

  12594.                         //

    12595. 

  12595.                     WriteARLog($this->_sTo,$this->_sSubject,

    12596. 

  12596.                                 GetMessage(MSG_LOG_RECAPTCHA,array("ERR"=>$s_error),false));

    12597. 

  12597.                     UserError("recaptcha",GetMessage(MSG_RECAPTCHA_MATCH,array("ERR"=>$s_error)));

    12598. 

  12598.                 }

    12599. 

  12599.             }

    12600. 

  12600.                 //

    12601. 

  12601.                 // now check for our verifyimg or Captcha Creator

    12602. 

  12602.                 //

    12603. 

  12603.             elseif ($SPECIAL_VALUES["arverify"] !== "")

    12604. 

  12604.             {

    12605. 

  12605.                     //

    12606. 

  12606.                     // allow spaces in the user's input, except for reCaptcha

    12607. 

  12607.                     //

    12608. 

  12608.                 $s_arverify = str_replace(" ","",$SPECIAL_VALUES["arverify"]);

    12609. 

  12609.                 $this->_iCaptchaType = $this->_iFull;

    12610. 

  12610.                     //

    12611. 

  12611.                     // full CAPTCHA has been attempted

    12612. 

  12612.                     // VerifyImgString is from Tectite's simple verifyimg.php CAPTCHA.

    12613. 

  12613.                     // turing_string is from Captcha Creator

    12614. 

  12614.                     //

    12615. 

  12615.                 if (IsSetSession("VerifyImgString") || IsSetSession("turing_string"))

    12616. 

  12616.                 {

    12617. 

  12617.                     $b_match = false;

    12618. 

  12618.                         //

    12619. 

  12619.                         // the user's entry must match the value in the session

    12620. 

  12620.                         //

    12621. 

  12621.                     if (IsSetSession("VerifyImgString"))

    12622. 

  12622.                     {

    12623. 

  12623.                         if (strtoupper($s_arverify) === strtoupper(GetSession("VerifyImgString")))

    12624. 

  12624.                             $b_match = true;

    12625. 

  12625.                     }

    12626. 

  12626.                     else

    12627. 

  12627.                     {

    12628. 

  12628.                         if (strtoupper($s_arverify) === strtoupper(GetSession("turing_string")))

    12629. 

  12629.                             $b_match = true;

    12630. 

  12630.                     }

    12631. 

  12631.                     if ($b_match)

    12632. 

  12632.                         $this->_bCaptchaOK = true;

    12633. 

  12633.                     else

    12634. 

  12634.                     {

    12635. 

  12635.                         WriteARLog($this->_sTo,$this->_sSubject,

    12636. 

  12636.                                     GetMessage(MSG_LOG_NO_MATCH,array(),false));

    12637. 

  12637.                         UserError("ar_verify",GetMessage(MSG_ARESP_NO_MATCH));

    12638. 

  12638.                     }

    12639. 

  12639.                 }

    12640. 

  12640.                 else

    12641. 

  12641.                 {

    12642. 

  12642.                         //

    12643. 

  12643.                         // ...and it has failed because there's no session data

    12644. 

  12644.                         //

    12645. 

  12645.                     WriteARLog($this->_sTo,$this->_sSubject,

    12646. 

  12646.                             GetMessage(MSG_LOG_NO_VERIMG,array(),false));

    12647. 

  12647.                     ErrorWithIgnore("verify_failed",GetMessage(MSG_ARESP_NO_AUTH),true);

    12648. 

  12648.                 }

    12649. 

  12649.             }

    12650. 

  12650.             elseif (ENABLE_ATTACK_DETECTION && !empty($ATTACK_DETECTION_REVERSE_CAPTCHA))

    12651. 

  12651.             {

    12652. 

  12652.                     //

    12653. 

  12653.                     // Reverse CAPTCHA has been configured

    12654. 

  12654.                     //

    12655. 

  12655.                 $this->_iCaptchaType = $this->_iRev;

    12656. 

  12656.                 $this->_bCaptchaOK = $bReverseCaptchaCompleted;

    12657. 

  12657.             }

    12658. 

  12658.         }

    12659. 

  12659.     }

    12660. 

  12660. 

    12661. 

  12661.     /*

    12662. 

  12662.      * Method:      AutoResponder::_Send

    12663. 

  12663.      * Parameters:  $b_use_template  if true, allow template, otherwise file

    12664. 

  12664.      * Returns:     void

    12665. 

  12665.      * Description: 

    12666. 

  12666.      *  Sends an autoreponse using a template.

    12667. 

  12667.      */

    12668. 

  12668.     function    _Send($b_use_template)

    12669. 

  12669.     {

    12670. 

  12670.         global  $SPECIAL_VALUES,$HOOK_DIR;

    12671. 

  12671.             //

    12672. 

  12672.             // declare some global vars for the hook system calls below

    12673. 

  12673.             //

    12674. 

  12674.         global  $aFieldOrder,$aCleanedValues,$aRawDataValues,$aAllRawValues,$aFileVars;

    12675. 

  12675. 

    12676. 

  12676.         FMDebug("Sending auto response: ".($b_use_template ? "template" : "plain"));

    12677. 

  12677. 

    12678. 

  12678.             //

    12679. 

  12679.             // Hook system: before sending auto response

    12680. 

  12680.             //

    12681. 

  12681.         if ($HOOK_DIR !== "")

    12682. 

  12682.         {

    12683. 

  12683.             if (!@include("$HOOK_DIR/fmhookprearesp.inc.php"))

    12684. 

  12684.                 @include("$HOOK_DIR/fmhookprearesp.inc");

    12685. 

  12685.         }

    12686. 

  12686.         if (!$this->_SendEmail($this->_sTo,$this->_sSubject,$aRawDataValues,$b_use_template))

    12687. 

  12687.         {

    12688. 

  12688.             WriteARLog($this->_sTo,$this->_sSubject,

    12689. 

  12689.                         GetMessage(MSG_LOG_FAILED,array(),false));

    12690. 

  12690.             SendAlert(GetMessage(MSG_ARESP_FAILED));

    12691. 

  12691.         }

    12692. 

  12692.         else

    12693. 

  12693.         {

    12694. 

  12694.             WriteARLog($this->_sTo,$this->_sSubject,

    12695. 

  12695.                         GetMessage(MSG_LOG_OK,array(),false));

    12696. 

  12696.                 //

    12697. 

  12697.                 // Hook system: after sending auto response

    12698. 

  12698.                 //

    12699. 

  12699.             if ($HOOK_DIR !== "")

    12700. 

  12700.                 if (!@include("$HOOK_DIR/fmhookpostaresp.inc.php"))

    12701. 

  12701.                     @include("$HOOK_DIR/fmhookpostaresp.inc");

    12702. 

  12702.         }

    12703. 

  12703.     }

    12704. 

  12704. 

    12705. 

  12705.     /*

    12706. 

  12706.      * Method:      AutoResponder::_SendEmail

    12707. 

  12707.      * Parameters:  $s_to       the email address to send to

    12708. 

  12708.      *              $s_subj     the subject line

    12709. 

  12709.      *              $a_values   field values to access

    12710. 

  12710.      *              $b_use_template if true, use a template, otherwise plain file

    12711. 

  12711.      * Returns:     bool        true on success, otherwise false

    12712. 

  12712.      * Description: 

    12713. 

  12713.      *  Sends an autoresponse email to the user.

    12714. 

  12714.      */

    12715. 

  12715.     function _SendEmail($s_to,$s_subj,$a_values,$b_use_template)

    12716. 

  12716.     {

    12717. 

  12717.         global  $aPHPVERSION,$SPECIAL_VALUES,$FROM_USER;

    12718. 

  12718. 

    12719. 

  12719.             //

    12720. 

  12720.             // need PHP 4.0.5 for the preg_replace_callback function

    12721. 

  12721.             //

    12722. 

  12722.         if (!IsPHPAtLeast("4.0.5"))

    12723. 

  12723.         {

    12724. 

  12724.             SendAlert(GetMessage(MSG_PHP_AUTORESP,

    12725. 

  12725.                             array("PHPVERS"=>implode(".",$aPHPVERSION))));

    12726. 

  12726.             return (false);

    12727. 

  12727.         }

    12728. 

  12728. 

    12729. 

  12729.         $a_headers = array();

    12730. 

  12730.         $s_mail_text = "";

    12731. 

  12731.         $s_from_addr = GetAROption("FromAddr");

    12732. 

  12732. 

    12733. 

  12733.         if (!isset($s_from_addr))

    12734. 

  12734.         {

    12735. 

  12735.             $s_from_addr = "";

    12736. 

  12736.             if (isset($FROM_USER) && !empty($FROM_USER))

    12737. 

  12737.             {

    12738. 

  12738.                 if ($FROM_USER != "NONE")

    12739. 

  12739.                     $s_from_addr = $FROM_USER;

    12740. 

  12740.             }

    12741. 

  12741.             else

    12742. 

  12742.             {

    12743. 

  12743.                 global  $SERVER;

    12744. 

  12744. 

    12745. 

  12745.                 $s_from_addr = "FormMail@".$SERVER;

    12746. 

  12746.             }

    12747. 

  12747.         }

    12748. 

  12748.         else

    12749. 

  12749.             $s_from_addr = UnMangle($s_from_addr);

    12750. 

  12750. 

    12751. 

  12751.         if (!empty($s_from_addr))

    12752. 

  12752.             $a_headers['From'] = SafeHeader($s_from_addr);

    12753. 

  12753. 

    12754. 

  12754.         $s_type = "";

    12755. 

  12755.         if ($b_use_template)

    12756. 

  12756.         {

    12757. 

  12757.             if (IsAROptionSet('PlainTemplate'))

    12758. 

  12758.             {

    12759. 

  12759.                 $s_type .= "PlainTemplate ";

    12760. 

  12760.                 $s_template = GetAROption("PlainTemplate");

    12761. 

  12761.                 if (!ProcessTemplate($s_template,$a_lines,$a_values,

    12762. 

  12762.                                             GetAROption('TemplateMissing'),

    12763. 

  12763.                                             'SubstituteValuePlain'))

    12764. 

  12764.                     return (false);

    12765. 

  12765.                 FMDebug("AutoRespond: PlainTemplate ".count($a_lines)." lines");

    12766. 

  12766.                 $s_mail_text = implode(BODY_LF,$a_lines);

    12767. 

  12767.             }

    12768. 

  12768.             if (IsAROptionSet("HTMLTemplate"))

    12769. 

  12769.             {

    12770. 

  12770.                 $s_type .= "HTMLTemplate ";

    12771. 

  12771.                 if (!MakeMimeMail($s_mail_text,$a_headers,$a_values,

    12772. 

  12772.                                     GetAROption("HTMLTemplate"),

    12773. 

  12773.                                     GetAROption('TemplateMissing')))

    12774. 

  12774.                     return (false);

    12775. 

  12775.                 FMDebug("AutoRespond: HTMLTemplate ".strlen($s_mail_text)." bytes");

    12776. 

  12776.             }

    12777. 

  12777.         }

    12778. 

  12778.         else

    12779. 

  12779.         {

    12780. 

  12780.             global  $TEMPLATEURL,$TEMPLATEDIR;

    12781. 

  12781. 

    12782. 

  12782.             if (IsAROptionSet('PlainFile'))

    12783. 

  12783.             {

    12784. 

  12784.                 $s_type .= "PlainFile ";

    12785. 

  12785.                     //

    12786. 

  12786.                     // load the plain text file from the templates area

    12787. 

  12787.                     //

    12788. 

  12788.                 if (empty($TEMPLATEDIR) && empty($TEMPLATEURL))

    12789. 

  12789.                 {

    12790. 

  12790.                     SendAlert(GetMessage(MSG_TEMPLATES));

    12791. 

  12791.                     return (false);

    12792. 

  12792.                 }

    12793. 

  12793.                 $s_file = GetAROption("PlainFile");

    12794. 

  12794.                 if (($a_lines = LoadTemplate($s_file,$TEMPLATEDIR,$TEMPLATEURL,true)) === false)

    12795. 

  12795.                     return (false);

    12796. 

  12796.                 $s_mail_text = implode(BODY_LF,$a_lines);

    12797. 

  12797.                 FMDebug("AutoRespond: PlainFile ".count($a_lines)." lines");

    12798. 

  12798.             }

    12799. 

  12799.             if (IsAROptionSet("HTMLFile"))

    12800. 

  12800.             {

    12801. 

  12801.                 $s_type .= "HTMLFile ";

    12802. 

  12802.                 if (!MakeMimeMail($s_mail_text,$a_headers,$a_values,

    12803. 

  12803.                                     GetAROption("HTMLFile"),"",

    12804. 

  12804.                                     false,"",array(),array(),false))

    12805. 

  12805.                     return (false);

    12806. 

  12806.                 FMDebug("AutoRespond: HTMLTemplate ".strlen($s_mail_text)." bytes");

    12807. 

  12807.             }

    12808. 

  12808.         }

    12809. 

  12809.         if (strlen($s_mail_text) == 0)

    12810. 

  12810.             SendAlert(GetMessage(MSG_ARESP_EMPTY),array("TYPE"=>$s_type));

    12811. 

  12811.         FMDebug("AutoRespond: message is ".strlen($s_mail_text)." bytes");

    12812. 

  12812.         return (SendCheckedMail($s_to,$s_subj,$s_mail_text,$s_from_addr,$a_headers));

    12813. 

  12813.     }

    12814. 

  12814. }

    12815. 

  12815. 

    12816. 

  12816. /* 

    12817. 

  12817.  * Class:       SessionAccess

    12818. 

  12818.  * Description:     

    12819. 

  12819.  *  Implements access to the general PHP session.

    12820. 

  12820.  *  This provides a secure way of copy data to and from the

    12821. 

  12821.  *  user's PHP session.

    12822. 

  12822.  */

    12823. 

  12823. class   SessionAccess

    12824. 

  12824. {

    12825. 

  12825.     var     $_aAccessList;

    12826. 

  12826. 

    12827. 

  12827.     /*

    12828. 

  12828.      * Method:      SessionAccess ctor

    12829. 

  12829.      * Parameters:  $a_access_list      list of variables that can be accessed

    12830. 

  12830.      * Returns:     n/a

    12831. 

  12831.      * Description: 

    12832. 

  12832.      *  Constructs the object.

    12833. 

  12833.      */

    12834. 

  12834.     function    SessionAccess($a_access_list)

    12835. 

  12835.     {

    12836. 

  12836.         $this->_aAccessList = $a_access_list;

    12837. 

  12837.     }

    12838. 

  12838. 

    12839. 

  12839.     /*

    12840. 

  12840.      * Method:      SessionAccess::CopyIn

    12841. 

  12841.      * Parameters:  $a_vars     reference to an array of values (keyed on name)

    12842. 

  12842.      *              $b_overwrite_empty  if true, the session value will overwrite

    12843. 

  12843.      *                          an empty array variable

    12844. 

  12844.      * Returns:     int         number of values copied

    12845. 

  12845.      * Description: 

    12846. 

  12846.      *  Copies in the list of variables from the session to the given array.

    12847. 

  12847.      */

    12848. 

  12848.     function    CopyIn(&$a_vars,$b_overwrite_empty)

    12849. 

  12849.     {

    12850. 

  12850.         //$s_db = "Session CopyIn:\n";

    12851. 

  12851.         $n_copied = 0;

    12852. 

  12852.         foreach ($this->_aAccessList as $s_var_name)

    12853. 

  12853.             if (IsSetSession($s_var_name))

    12854. 

  12854.                 if (!isset($a_vars[$s_var_name]) ||

    12855. 

  12855.                         ($b_overwrite_empty &&

    12856. 

  12856.                         FieldManager::IsEmpty($a_vars[$s_var_name])))

    12857. 

  12857.                 {

    12858. 

  12858.                     $a_vars[$s_var_name] = GetSession($s_var_name);

    12859. 

  12859.                     //$s_db .= "$s_var_name='".$a_vars[$s_var_name]."'\n";

    12860. 

  12860.                     $n_copied++;

    12861. 

  12861.                 };

    12862. 

  12862.         //SendAlert($s_db);

    12863. 

  12863.         return ($n_copied);

    12864. 

  12864.     }

    12865. 

  12865. 

    12866. 

  12866.     /*

    12867. 

  12867.      * Method:      SessionAccess::CopyOut

    12868. 

  12868.      * Parameters:  $a_vars     reference to an array of values (keyed on name)

    12869. 

  12869.      *              $a_fields   an array of fields to copy

    12870. 

  12870.      * Returns:     int         number of values copied

    12871. 

  12871.      * Description: 

    12872. 

  12872.      *  Copies the variables from the given array into the session.

    12873. 

  12873.      *  The list of fields to copy is specified in _aAccessList.

    12874. 

  12874.      *  If $a_fields is provided, it contains a list of fields to copy, which

    12875. 

  12875.      *  limits the fields selected from _aAccessList, otherwise all fields

    12876. 

  12876.      *  listed in _aAccessList are copied.

    12877. 

  12877.      */

    12878. 

  12878.     function    CopyOut(&$a_vars,$a_fields = array())

    12879. 

  12879.     {

    12880. 

  12880.         //$s_db = "Session CopyOut:\n";

    12881. 

  12881. 

    12882. 

  12882.         $n_copied = 0;

    12883. 

  12883.         foreach ($this->_aAccessList as $s_var_name)

    12884. 

  12884.             if (isset($a_vars[$s_var_name]))

    12885. 

  12885.                 if (empty($a_fields) || in_array($s_var_name,$a_fields))

    12886. 

  12886.                 {

    12887. 

  12887.                     SetSession($s_var_name,$a_vars[$s_var_name]);

    12888. 

  12888.                     //$s_db .= "$s_var_name='".GetSession($s_var_name)."'\n";

    12889. 

  12889.                     $n_copied++;

    12890. 

  12890.                 };

    12891. 

  12891.         //SendAlert($s_db);

    12892. 

  12892.         return ($n_copied);

    12893. 

  12893.     }

    12894. 

  12894. };

    12895. 

  12895. 

    12896. 

  12896. $SessionAccessor = new SessionAccess($SESSION_ACCESS);

    12897. 

  12897. 

    12898. 

  12898. $bAdvTemplates = false;

    12899. 

  12899. if (ADVANCED_TEMPLATES &&

    12900. 

  12900.         (!empty($TEMPLATEDIR) || !empty($TEMPLATEURL) ||

    12901. 

  12901.         !empty($MULTIFORMDIR) || !empty($MULTIFORMURL)))

    12902. 

  12902.     $bAdvTemplates = true;

    12903. 

  12903. 

    12904. 

  12904. if (isset($aGetVars["return"]) && is_numeric($aGetVars["return"]))

    12905. 

  12905. {

    12906. 

  12906.         //

    12907. 

  12907.         // if advanced templates are in use, we will need them for

    12908. 

  12908.         // performing a multi-page form return

    12909. 

  12909.         //

    12910. 

  12910.     if ($bAdvTemplates)

    12911. 

  12911.     {

    12912. 

  12912.         $FMCTEMPLATE_PROC = true;

    12913. 

  12913.         if (!include_once("$MODULEDIR/$FMCOMPUTE"))

    12914. 

  12914.             Error("load_fmcompute",GetMessage(MSG_LOAD_FMCOMPUTE,

    12915. 

  12915.                             array("FILE"=>"$MODULEDIR/$FMCOMPUTE",

    12916. 

  12916.                                     "ERROR"=>$php_errormsg)),false,false);

    12917. 

  12917.     }

    12918. 

  12918.     MultiFormReturn($aGetVars["return"]);

    12919. 

  12919.     exit;

    12920. 

  12920. }

    12921. 

  12921. 

    12922. 

  12922.     //

    12923. 

  12923.     // Hook system: after initialization

    12924. 

  12924.     //

    12925. 

  12925. if ($HOOK_DIR !== "")

    12926. 

  12926.     if (!@include("$HOOK_DIR/fmhookpostinit.inc.php"))

    12927. 

  12927. 		@include("$HOOK_DIR/fmhookpostinit.inc");

    12928. 

  12928. 

    12929. 

  12929.     //

    12930. 

  12930.     // check configuration values for potential security problems

    12931. 

  12931.     //

    12932. 

  12932. CheckConfig();

    12933. 

  12933. 

    12934. 

  12934.     //

    12935. 

  12935.     // otherwise, do the real processing of FormMail

    12936. 

  12936.     //

    12937. 

  12937. $aStrippedFormVars = $aAllRawValues = StripGPCArray($aFormVars);

    12938. 

  12938. 

    12939. 

  12939. if (ENABLE_ATTACK_DETECTION)

    12940. 

  12940.     DetectAttacks($aAllRawValues);

    12941. 

  12941. 

    12942. 

  12942.     //

    12943. 

  12943.     // Copy in configured session variables, overwriting any

    12944. 

  12944.     // fields that are empty.

    12945. 

  12945.     //

    12946. 

  12946. $SessionAccessor->CopyIn($aAllRawValues,true);

    12947. 

  12947. $SessionAccessor->CopyIn($aStrippedFormVars,true);

    12948. 

  12948. 

    12949. 

  12949.     //

    12950. 

  12950.     // process the options

    12951. 

  12951.     //

    12952. 

  12952. ProcessMailOptions($aAllRawValues);

    12953. 

  12953. ProcessCRMOptions($aAllRawValues);

    12954. 

  12954. ProcessAROptions($aAllRawValues);

    12955. 

  12955. ProcessFilterOptions($aAllRawValues);

    12956. 

  12956. 

    12957. 

  12957.     //

    12958. 

  12958.     // create any derived fields

    12959. 

  12959.     // NOTE: it's important that derivation occurs before cleaned values

    12960. 

  12960.     // are created.  If derivation occurred after cleaning or it created

    12961. 

  12961.     // fields that were assumed to be clean, then an attack could create

    12962. 

  12962.     // forged email headers using derive_fields.  The code is safe with

    12963. 

  12963.     // the logic sequence below.

    12964. 

  12964.     //

    12965. 

  12965. $aAllRawValues = CreateDerived($aAllRawValues);

    12966. 

  12966. 

    12967. 

  12967. list($aFieldOrder,$aCleanedValues,$aRawDataValues) = ParseInput($aAllRawValues);

    12968. 

  12968. 

    12969. 

  12969. FilterFiles($aFileVars);

    12970. 

  12970. 

    12971. 

  12971.     //

    12972. 

  12972.     // if we're processing multi-forms, then merge in the raw data from previous

    12973. 

  12973.     // forms unless this is the first page of the form sequence

    12974. 

  12974.     //

    12975. 

  12975. if (IsSetSession("FormList") && $SPECIAL_VALUES["multi_start"] != 1)

    12976. 

  12976. {

    12977. 

  12977.     list($aFieldOrder,$aCleanedValues,

    12978. 

  12978.             $aRawDataValues,$aAllRawValues,$aFileVars) = GetMultiValues(

    12979. 

  12979.                             GetSession("FormList"),

    12980. 

  12980.                             GetSession("FormIndex"),

    12981. 

  12981.                             $aFieldOrder,$aCleanedValues,

    12982. 

  12982.                             $aRawDataValues,$aAllRawValues,

    12983. 

  12983.                             $aFileVars);

    12984. 

  12984. }

    12985. 

  12985. 

    12986. 

  12986. if ($SPECIAL_VALUES["file_names"] !== "")

    12987. 

  12987.     list($aFieldOrder,$aCleanedValues,$aRawDataValues,$aAllRawValues,$aFileVars) =

    12988. 

  12988.             SetFileNames($SPECIAL_VALUES["file_names"],$aFieldOrder,

    12989. 

  12989.                     $aCleanedValues,$aRawDataValues,$aAllRawValues,$aFileVars);

    12990. 

  12990. 

    12991. 

  12991.     //

    12992. 

  12992.     // Hook system: after loading and processing data

    12993. 

  12993.     //

    12994. 

  12994. if ($HOOK_DIR !== "")

    12995. 

  12995.     if (!@include("$HOOK_DIR/fmhookload.inc.php"))

    12996. 

  12996. 		@include("$HOOK_DIR/fmhookload.inc");

    12997. 

  12997. 

    12998. 

  12998. if ($FORM_INI_FILE !== "")

    12999. 

  12999. {

    13000. 

  13000.     ProcessFormIniFile($FORM_INI_FILE);

    13001. 

  13001.         //

    13002. 

  13002.         // Hook system: after processing INI file

    13003. 

  13003.         //

    13004. 

  13004.     if ($HOOK_DIR !== "")

    13005. 

  13005.         if (!@include("$HOOK_DIR/fmhookinifile.inc.php"))

    13006. 

  13006. 		    @include("$HOOK_DIR/fmhookinifile.inc");

    13007. 

  13007. }

    13008. 

  13008. 

    13009. 

  13009. $bDoneSomething = false;

    13010. 

  13010. if (DB_SEE_INPUT)

    13011. 

  13011. {

    13012. 

  13012.     /***

    13013. 

  13013.     echo "<pre>";

    13014. 

  13014.     print_r($aFormVars);

    13015. 

  13015.     print_r($aServerVars);

    13016. 

  13016.     echo "</pre>";

    13017. 

  13017.     exit;

    13018. 

  13018.     ****/

    13019. 

  13019.     CreatePage(implode("\n",$FORMATTED_INPUT),"Debug Output - Fields Submitted");

    13020. 

  13020.     ZapSession();

    13021. 

  13021.     exit;

    13022. 

  13022. }

    13023. 

  13023. 

    13024. 

  13024. if (!empty($SPECIAL_VALUES["fmcompute"]) || $bAdvTemplates)

    13025. 

  13025. {

    13026. 

  13026.     $FM_UserErrors = array();

    13027. 

  13027.         //

    13028. 

  13028.         // Generalized interface between FMCompute and FormMail functions

    13029. 

  13029.         //

    13030. 

  13030.     function FM_CallFunction($s_func,$a_params,&$m_return,

    13031. 

  13031.                                 &$s_mesg,&$a_debug,&$a_alerts)

    13032. 

  13032.     {

    13033. 

  13033.         switch ($s_func)

    13034. 

  13034.         {

    13035. 

  13035.         case "FMFatalError":

    13036. 

  13036.             SendComputeAlerts();

    13037. 

  13037.             if (count($a_params) < 3)

    13038. 

  13038.                 Error("fmcompute_call",GetMessage(MSG_CALL_PARAM_COUNT,

    13039. 

  13039.                                         array("FUNC"=>$s_func,

    13040. 

  13040.                                             "COUNT"=>count($a_params))),

    13041. 

  13041.                                         false,false);

    13042. 

  13042.             else

    13043. 

  13043.                 Error("fmcompute_error",$a_params[0],$a_params[1],$a_params[2]);

    13044. 

  13044.             break;

    13045. 

  13045. 

    13046. 

  13046.         case "FMFatalUserError":

    13047. 

  13047.             SendComputeAlerts();

    13048. 

  13048.             if (count($a_params) < 1)

    13049. 

  13049.                 Error("fmcompute_call",GetMessage(MSG_CALL_PARAM_COUNT,

    13050. 

  13050.                                         array("FUNC"=>$s_func,

    13051. 

  13051.                                             "COUNT"=>count($a_params))),

    13052. 

  13052.                                         false,false);

    13053. 

  13053.             else

    13054. 

  13054.                 UserError("fmcompute_usererror",$a_params[0]);

    13055. 

  13055.             break;

    13056. 

  13056. 

    13057. 

  13057.         case "FMUserError":

    13058. 

  13058.             if (count($a_params) < 1)

    13059. 

  13059.             {

    13060. 

  13060.                 SendComputeAlerts();

    13061. 

  13061.                 Error("fmcompute_call",GetMessage(MSG_CALL_PARAM_COUNT,

    13062. 

  13062.                                         array("FUNC"=>$s_func,

    13063. 

  13063.                                             "COUNT"=>count($a_params))),

    13064. 

  13064.                                         false,false);

    13065. 

  13065.             }

    13066. 

  13066.             else

    13067. 

  13067.             {

    13068. 

  13068.                 global  $FM_UserErrors;

    13069. 

  13069. 

    13070. 

  13070.                 $FM_UserErrors[] = $a_params[0];

    13071. 

  13071.             }

    13072. 

  13072.             break;

    13073. 

  13073. 

    13074. 

  13074.         case "FMSaveAllFilesToRepository":

    13075. 

  13075.             if (count($a_params) != 0)

    13076. 

  13076.             {

    13077. 

  13077.                 SendComputeAlerts();

    13078. 

  13078.                 Error("fmcompute_call",GetMessage(MSG_CALL_PARAM_COUNT,

    13079. 

  13079.                                         array("FUNC"=>$s_func,

    13080. 

  13080.                                             "COUNT"=>count($a_params))),

    13081. 

  13081.                                         false,false);

    13082. 

  13082.             }

    13083. 

  13083.             else

    13084. 

  13084.                 $m_return = SaveAllFilesToRepository();

    13085. 

  13085.             break;

    13086. 

  13086. 

    13087. 

  13087.         case "FMDeleteFileFromRepository":

    13088. 

  13088.             if (count($a_params) != 1)

    13089. 

  13089.             {

    13090. 

  13090.                 SendComputeAlerts();

    13091. 

  13091.                 Error("fmcompute_call",GetMessage(MSG_CALL_PARAM_COUNT,

    13092. 

  13092.                                         array("FUNC"=>$s_func,

    13093. 

  13093.                                             "COUNT"=>count($a_params))),

    13094. 

  13094.                                         false,false);

    13095. 

  13095.             }

    13096. 

  13096.             else

    13097. 

  13097.                 $m_return = DeleteFileFromRepository($a_params[0]);

    13098. 

  13098.             break;

    13099. 

  13099. 

    13100. 

  13100.         case "FMNextNum":

    13101. 

  13101.             if (count($a_params) != 2)

    13102. 

  13102.             {

    13103. 

  13103.                 SendComputeAlerts();

    13104. 

  13104.                 Error("fmcompute_call",GetMessage(MSG_CALL_PARAM_COUNT,

    13105. 

  13105.                                         array("FUNC"=>$s_func,

    13106. 

  13106.                                             "COUNT"=>count($a_params))),

    13107. 

  13107.                                         false,false);

    13108. 

  13108.             }

    13109. 

  13109.             else

    13110. 

  13110.             {

    13111. 

  13111.                 $i_pad = $a_params[0];

    13112. 

  13112.                 $i_base = $a_params[1];

    13113. 

  13113.                 if ($i_base < 2 || $i_base > 36)

    13114. 

  13114.                     Error("fmcompute_call",GetMessage(MSG_CALL_INVALID_PARAM,

    13115. 

  13115.                                             array("FUNC"=>$s_func,

    13116. 

  13116.                                                 "PARAM"=>2,

    13117. 

  13117.                                                 "CORRECT"=>2...36)),

    13118. 

  13118.                                             false,false);

    13119. 

  13119.                 $m_return = GetNextNum($i_pad,$i_base);

    13120. 

  13120.             }

    13121. 

  13121.             break;

    13122. 

  13122. 

    13123. 

  13123.         default:

    13124. 

  13124.             $s_mesg = GetMessage(MSG_CALL_UNK_FUNC,array("FUNC"=>$s_func));

    13125. 

  13125.             return (false);

    13126. 

  13126.         }

    13127. 

  13127.         return (true);

    13128. 

  13128.     }

    13129. 

  13129. 

    13130. 

  13130.         //

    13131. 

  13131.         // register useful FormMail functions with FMCompute module

    13132. 

  13132.         //

    13133. 

  13133.     function RegisterFormMailFunctions(&$fmc)

    13134. 

  13134.     {

    13135. 

  13135.             //

    13136. 

  13136.             // Allows the user to call "Error" from within a computation

    13137. 

  13137.             //

    13138. 

  13138.         if (($s_msg = $fmc->RegisterExternalFunction("PHP","void",

    13139. 

  13139.                             "FMFatalError",

    13140. 

  13140.                             array("string","bool","bool"),

    13141. 

  13141.                             "FM_CallFunction")) !== true)

    13142. 

  13142.             Error("fmcompute_reg",GetMessage(MSG_REG_FMCOMPUTE,

    13143. 

  13143.                                     array("FUNC"=>"FMFatalError",

    13144. 

  13144.                                           "ERROR"=>$s_msg)),false,false);

    13145. 

  13145.             //

    13146. 

  13146.             // Allows the user to call "UserError" from within a computation

    13147. 

  13147.             //

    13148. 

  13148.         if (($s_msg = $fmc->RegisterExternalFunction("PHP","void",

    13149. 

  13149.                             "FMFatalUserError",

    13150. 

  13150.                             array("string"),

    13151. 

  13151.                             "FM_CallFunction")) !== true)

    13152. 

  13152.             Error("fmcompute_reg",GetMessage(MSG_REG_FMCOMPUTE,

    13153. 

  13153.                                     array("FUNC"=>"FMFatalUserError",

    13154. 

  13154.                                           "ERROR"=>$s_msg)),false,false);

    13155. 

  13155. 

    13156. 

  13156.             //

    13157. 

  13157.             // Allows the user to record an error to be displayed

    13158. 

  13158.             // from within a computation.

    13159. 

  13159.             //

    13160. 

  13160.         if (($s_msg = $fmc->RegisterExternalFunction("PHP","void",

    13161. 

  13161.                             "FMUserError",

    13162. 

  13162.                             array("string"),

    13163. 

  13163.                             "FM_CallFunction")) !== true)

    13164. 

  13164.             Error("fmcompute_reg",GetMessage(MSG_REG_FMCOMPUTE,

    13165. 

  13165.                                     array("FUNC"=>"FMUserError",

    13166. 

  13166.                                           "ERROR"=>$s_msg)),false,false);

    13167. 

  13167. 

    13168. 

  13168.             //

    13169. 

  13169.             // Saves files to the repository.

    13170. 

  13170.             //

    13171. 

  13171.         if (($s_msg = $fmc->RegisterExternalFunction("PHP","bool",

    13172. 

  13172.                             "FMSaveAllFilesToRepository",

    13173. 

  13173.                             array(),

    13174. 

  13174.                             "FM_CallFunction")) !== true)

    13175. 

  13175.             Error("fmcompute_reg",GetMessage(MSG_REG_FMCOMPUTE,

    13176. 

  13176.                                     array("FUNC"=>"FMSaveAllFilesToRepository",

    13177. 

  13177.                                           "ERROR"=>$s_msg)),false,false);

    13178. 

  13178. 

    13179. 

  13179.             //

    13180. 

  13180.             // Delete a file from the repository.

    13181. 

  13181.             //

    13182. 

  13182.         if (($s_msg = $fmc->RegisterExternalFunction("PHP","bool",

    13183. 

  13183.                             "FMDeleteFileFromRepository",

    13184. 

  13184.                             array("string"),

    13185. 

  13185.                             "FM_CallFunction")) !== true)

    13186. 

  13186.             Error("fmcompute_reg",GetMessage(MSG_REG_FMCOMPUTE,

    13187. 

  13187.                                     array("FUNC"=>"FMDeleteFileFromRepository",

    13188. 

  13188.                                           "ERROR"=>$s_msg)),false,false);

    13189. 

  13189. 

    13190. 

  13190.             //

    13191. 

  13191.             // Generate a Next Number

    13192. 

  13192.             //

    13193. 

  13193.         if (($s_msg = $fmc->RegisterExternalFunction("PHP","string",

    13194. 

  13194.                             "FMNextNum",

    13195. 

  13195.                             array("int","int"),

    13196. 

  13196.                             "FM_CallFunction")) !== true)

    13197. 

  13197.             Error("fmcompute_reg",GetMessage(MSG_REG_FMCOMPUTE,

    13198. 

  13198.                                     array("FUNC"=>"FMNextNum",

    13199. 

  13199.                                           "ERROR"=>$s_msg)),false,false);

    13200. 

  13200. 

    13201. 

  13201.     }

    13202. 

  13202. 

    13203. 

  13203.         //

    13204. 

  13204.         // load the fmcompute module

    13205. 

  13205.         //

    13206. 

  13206.     if (!empty($SPECIAL_VALUES["fmcompute"]))

    13207. 

  13207.     {

    13208. 

  13208.         $FMCOMPUTE_CLASS = true;

    13209. 

  13209.         $FMCOMPUTE_NODEBUG = true;

    13210. 

  13210.     }

    13211. 

  13211.     if ($bAdvTemplates)

    13212. 

  13212.         $FMCTEMPLATE_PROC = true;

    13213. 

  13213.     if (!include_once("$MODULEDIR/$FMCOMPUTE"))

    13214. 

  13214.         Error("load_fmcompute",GetMessage(MSG_LOAD_FMCOMPUTE,

    13215. 

  13215.                         array("FILE"=>"$MODULEDIR/$FMCOMPUTE",

    13216. 

  13216.                                 "ERROR"=>$php_errormsg)),false,false);

    13217. 

  13217.     if (!empty($SPECIAL_VALUES["fmcompute"]))

    13218. 

  13218.     {

    13219. 

  13219.         RegisterFormMailFunctions($FMCalc);

    13220. 

  13220. 

    13221. 

  13221.             //

    13222. 

  13222.             // if GeoIP support is specified, load that module now

    13223. 

  13223.             //

    13224. 

  13224.         if (!empty($GEOIP_LIC))

    13225. 

  13225.         {

    13226. 

  13226.             $FMMODULE_LOAD = true;      // signal module load

    13227. 

  13227.             if (!include_once("$MODULEDIR/$FMGEOIP"))

    13228. 

  13228.                 Error("load_module",GetMessage(MSG_LOAD_MODULE,

    13229. 

  13229.                                 array("FILE"=>"$MODULEDIR/$FMGEOIP",

    13230. 

  13230.                                         "ERROR"=>$php_errormsg)),false,false);

    13231. 

  13231.                 //

    13232. 

  13232.                 // load the license and register the module

    13233. 

  13233.                 //

    13234. 

  13234.             $GeoIP = new FMGeoIP($GEOIP_LIC);

    13235. 

  13235.             if (!$GeoIP->RegisterModule($FMCalc))

    13236. 

  13236.                 Error("reg_module",GetMessage(MSG_REGISTER_MODULE,

    13237. 

  13237.                                 array("NAME"=>"FMGeoIP",

    13238. 

  13238.                                        "ERROR"=>$GeoIP->GetError())),false,false);

    13239. 

  13239.         }

    13240. 

  13240.     }

    13241. 

  13241. }

    13242. 

  13242. 

    13243. 

  13243. if (isset($SPECIAL_VALUES["multi_go_back"]) && !empty($SPECIAL_VALUES["multi_go_back"]))

    13244. 

  13244. {

    13245. 

  13245.     if (!IsSetSession("FormList") || GetSession("FormIndex") == 0)

    13246. 

  13246.         ErrorWithIgnore("go_back",GetMessage(MSG_GO_BACK),false,false);

    13247. 

  13247.     MultiKeep();        // store any "multi_keep" data just submitted

    13248. 

  13248.         //

    13249. 

  13249.         // save back to the session any variables that have been specified in

    13250. 

  13250.         // multi_keep

    13251. 

  13251.         //

    13252. 

  13252.     if (isset($SPECIAL_VALUES["multi_keep"]) && !empty($SPECIAL_VALUES["multi_keep"]))

    13253. 

  13253.         $SessionAccessor->CopyOut($aAllRawValues,$SPECIAL_VALUES["multi_keep"]);

    13254. 

  13254.     MultiFormReturn(GetSession("FormIndex")-1);

    13255. 

  13255. //    echo "Form index = ".GetSession("FormIndex");

    13256. 

  13256.     exit;

    13257. 

  13257. }

    13258. 

  13258. 

    13259. 

  13259.     //

    13260. 

  13260.     // This is the check for spiders; I can't imagine a spider will

    13261. 

  13261.     // ever use the POST method.

    13262. 

  13262.     //

    13263. 

  13263. if ($bIsGetMethod && count($aFormVars) == 0)

    13264. 

  13264. {

    13265. 

  13265.     if (!$ALLOW_GET_METHOD && $bHasGetData)

    13266. 

  13266.         CreatePage(GetMessage(MSG_GET_DISALLOWED),GetMessage(MSG_FORM_ERROR));

    13267. 

  13267.     else

    13268. 

  13268.         CreatePage(GetMessage(MSG_NO_DATA_PAGE),GetMessage(MSG_FORM_ERROR));

    13269. 

  13269.     ZapSession();

    13270. 

  13270.     exit;

    13271. 

  13271. }

    13272. 

  13272. 

    13273. 

  13273.     //

    13274. 

  13274.     // Hook system: before performing required and conditions etc.

    13275. 

  13275.     //

    13276. 

  13276. if ($HOOK_DIR !== "")

    13277. 

  13277.     if (!@include("$HOOK_DIR/fmhookprechecks.inc.php"))

    13278. 

  13278. 		@include("$HOOK_DIR/fmhookprechecks.inc");

    13279. 

  13279. 

    13280. 

  13280.     //

    13281. 

  13281.     // check for required fields

    13282. 

  13282.     //

    13283. 

  13283. if (!CheckRequired($SPECIAL_VALUES["required"],$aAllRawValues,$sMissing,$aMissingList))

    13284. 

  13284.     UserError("missing_fields",GetMessage(MSG_REQD_ERROR),$sMissing,$aMissingList);

    13285. 

  13285. 

    13286. 

  13286.     //

    13287. 

  13287.     // check complex conditions

    13288. 

  13288.     //

    13289. 

  13289. if (!CheckConditions($SPECIAL_VALUES["conditions"],$aAllRawValues,$sMissing,$aMissingList))

    13290. 

  13290.     UserError("failed_conditions",GetMessage(MSG_COND_ERROR),$sMissing,$aMissingList);

    13291. 

  13291. 

    13292. 

  13292.     //

    13293. 

  13293.     // check CAPTCHA

    13294. 

  13294.     //

    13295. 

  13295. CheckCaptchaSubmit();

    13296. 

  13296. 

    13297. 

  13297.     //

    13298. 

  13298.     // Hook system: after performing required and conditions etc.

    13299. 

  13299.     //

    13300. 

  13300. if ($HOOK_DIR !== "")

    13301. 

  13301.     if (!@include("$HOOK_DIR/fmhookchecks.inc.php"))

    13302. 

  13302. 		@include("$HOOK_DIR/fmhookchecks.inc");

    13303. 

  13303. 

    13304. 

  13304. if (!empty($SPECIAL_VALUES["fmmodules"]))

    13305. 

  13305. {

    13306. 

  13306.     $aModuleList = TrimArray(explode(",",$SPECIAL_VALUES["fmmodules"]));

    13307. 

  13307.     $FMMODULE_LOAD = true;      // signal module load

    13308. 

  13308.     foreach ($aModuleList as $sModule)

    13309. 

  13309.         if (!include_once("$MODULEDIR/$sModule"))

    13310. 

  13310.             Error("load_module",GetMessage(MSG_LOAD_MODULE,

    13311. 

  13311.                             array("FILE"=>"$MODULEDIR/$sModule",

    13312. 

  13312.                                     "ERROR"=>$php_errormsg)),false,false);

    13313. 

  13313. }

    13314. 

  13314. 

    13315. 

  13315. if (!empty($SPECIAL_VALUES["fmcompute"]))

    13316. 

  13316. {

    13317. 

  13317.         //

    13318. 

  13318.         // Callback function for preg_replace_callback to add line

    13319. 

  13319.         // numbers on each match

    13320. 

  13320.         //

    13321. 

  13321.     function AddLineNumbersCallback($a_matches)

    13322. 

  13322.     {

    13323. 

  13323.         global  $iAddLineNumbersCounter;

    13324. 

  13324. 

    13325. 

  13325.         return (sprintf("%d:",++$iAddLineNumbersCounter).$a_matches[0]);

    13326. 

  13326.     }

    13327. 

  13327.         //

    13328. 

  13328.         // Add line numbers to some code

    13329. 

  13329.         //

    13330. 

  13330.     function AddLineNumbers($s_code)

    13331. 

  13331.     {

    13332. 

  13332.         global  $iAddLineNumbersCounter;

    13333. 

  13333. 

    13334. 

  13334.         $iAddLineNumbersCounter = 0;

    13335. 

  13335.         return (preg_replace_callback('/^/m','AddLineNumbersCallback',$s_code));

    13336. 

  13336.     }

    13337. 

  13337. 

    13338. 

  13338.         //

    13339. 

  13339.         // Load some more code into FMCalc

    13340. 

  13340.         //

    13341. 

  13341.     function Load($s_code)

    13342. 

  13342.     {

    13343. 

  13343.         global  $FMCalc;

    13344. 

  13344. 

    13345. 

  13345.         $a_mesgs = array();

    13346. 

  13346.        // echo "Loading '$s_code'";

    13347. 

  13347.         if ($FMCalc->Parse($s_code,$a_mesgs) === false)

    13348. 

  13348.         {

    13349. 

  13349.             $s_msgs = "";

    13350. 

  13350.             foreach ($a_mesgs as $a_msg)

    13351. 

  13351.             {

    13352. 

  13352.                 $s_msgs .= "Line ".$a_msg["LINE"];

    13353. 

  13353.                 $s_msgs .= ", position ".$a_msg["CHAR"].": ";

    13354. 

  13354.                 $s_msgs .= $a_msg["MSG"]."\n";

    13355. 

  13355.             }

    13356. 

  13356.             Error("fmcompute_parse",GetMessage(MSG_COMP_PARSE,

    13357. 

  13357.                         array("CODE"=>AddLineNumbers($s_code),

    13358. 

  13358.                                 "ERRORS"=>$s_msgs)),false,false);

    13359. 

  13359.         }

    13360. 

  13360.     }

    13361. 

  13361. 

    13362. 

  13362.         //

    13363. 

  13363.         // Send any alerts found in FMCalc

    13364. 

  13364.         //

    13365. 

  13365.     function SendComputeAlerts()

    13366. 

  13366.     {

    13367. 

  13367.         global  $FMCalc;

    13368. 

  13368. 

    13369. 

  13369.         $a_alerts = $FMCalc->GetAlerts();

    13370. 

  13370.         if (count($a_alerts) > 0)

    13371. 

  13371.             SendAlert(GetMessage(MSG_COMP_ALERT,

    13372. 

  13372.                         array("ALERTS"=>implode("\n",StripHTML($a_alerts)))));

    13373. 

  13373.         $a_debug = $FMCalc->GetDebug();

    13374. 

  13374.         if (count($a_debug) > 0)

    13375. 

  13375.             SendAlert(GetMessage(MSG_COMP_DEBUG,

    13376. 

  13376.                         array("DEBUG"=>implode("\n",StripHTML($a_debug)))));

    13377. 

  13377.     }

    13378. 

  13378.         //

    13379. 

  13379.         // Perform the computations in FMCalc

    13380. 

  13380.         //

    13381. 

  13381.     function Compute(&$a_field_order,&$a_cleaned_values,&$a_raw_data_values,

    13382. 

  13382.                             &$a_values)

    13383. 

  13383.     {

    13384. 

  13384.         global  $FMCalc,$FM_UserErrors;

    13385. 

  13385. 

    13386. 

  13386.         $a_mesgs = array();

    13387. 

  13387.         $FM_UserErrors = array();

    13388. 

  13388.         if (($a_flds = $FMCalc->Execute($a_mesgs)) !== false)

    13389. 

  13389.         {

    13390. 

  13390.             SendComputeAlerts();

    13391. 

  13391.             foreach ($a_flds as $s_name=>$s_value)

    13392. 

  13392.             {

    13393. 

  13393.                 $a_values[$s_name] = $s_value;

    13394. 

  13394.                 ProcessField($s_name,$s_value,$a_field_order,

    13395. 

  13395.                                 $a_cleaned_values,$a_raw_data_values);

    13396. 

  13396.             }

    13397. 

  13397.             if (count($FM_UserErrors) > 0)

    13398. 

  13398.                 UserError("fmcompute_usererrors",GetMessage(MSG_USER_ERRORS),

    13399. 

  13399.                                 "",$FM_UserErrors);

    13400. 

  13400.         }

    13401. 

  13401.         else

    13402. 

  13402.         {

    13403. 

  13403.             SendComputeAlerts();

    13404. 

  13404.             Error("fmcompute_exec",GetMessage(MSG_COMP_EXEC,

    13405. 

  13405.                         array("ERRORS"=>implode("\n",$a_mesgs))),false,false);

    13406. 

  13406.     
    13407.