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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
ModemConfig.c++
资源名称：hylafax-5.3.0.tar.gz　[点击查看]
上传用户：weiyuanprp
上传日期：2020-05-20
资源大小：1169k
文件大小：29k
源码类别：

传真(Fax)编程

开发平台：

C/C++

ModemConfig.c++：源码内容
  1. /* $Id: ModemConfig.c++,v 1.35 2008/09/30 05:33:27 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1990-1996 Sam Leffler
  4.  * Copyright (c) 1991-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26. #include "ModemConfig.h"
  28. #include "t.30.h"
  29. #include "config.h"
  30. #include "tiffio.h"
  32. #include <ctype.h>
  34. #define N(a) (sizeof (a) / sizeof (a[0]))
  36. ModemConfig::ModemConfig()
  37. {
  38.     setupConfig();
  39. }
  41. ModemConfig::~ModemConfig()
  42. {
  43. }
  45. const fxStr&
  46. ModemConfig::getFlowCmd(FlowControl f) const
  47. {
  48.     if (f == ClassModem::FLOW_RTSCTS)
  49. return (hardFlowCmd);
  50.     else if (f == ClassModem::FLOW_XONXOFF)
  51. return (softFlowCmd);
  52.     else if (f == ClassModem::FLOW_NONE)
  53. return (noFlowCmd);
  54.     else
  55. return (fxStr::null);
  56. }
  58. /*
  59.  * The following tables map configuration parameter names to
  60.  * pointers to class ModemConfig members and provide default
  61.  * values that are forced when the configuration is reset
  62.  * prior to reading a configuration file.
  63.  */
  65. /*
  66.  * Note that all of the Class 2/2.0 parameters except
  67.  * Class2CQQueryCmd are initialized at the time the
  68.  * modem is setup based on whether the modem is Class 2
  69.  * or Class 2.0.
  70.  */
  71. static struct {
  72.     const char*  name;
  73.     fxStr ModemConfig::* p;
  74.     const char*  def; // NULL is shorthand for ""
  75. } atcmds[] = {
  76. { "modemanswercmd", &ModemConfig::answerAnyCmd, "ATA" },
  77. { "modemansweranycmd", &ModemConfig::answerAnyCmd },
  78. { "modemanswerfaxcmd", &ModemConfig::answerFaxCmd },
  79. { "modemanswerdatacmd", &ModemConfig::answerDataCmd },
  80. { "modemanswervoicecmd", &ModemConfig::answerVoiceCmd },
  81. { "modemanswerdialcmd", &ModemConfig::answerDialCmd },
  82. { "modemanswerfaxbegincmd", &ModemConfig::answerFaxBeginCmd },
  83. { "modemanswerdatabegincmd", &ModemConfig::answerDataBeginCmd },
  84. { "modemanswervoicebegincmd", &ModemConfig::answerVoiceBeginCmd },
  85. { "modemringresponse", &ModemConfig::ringResponse },
  86. { "modemresetcmds", &ModemConfig::resetCmds },
  87. { "modemreadycmds", &ModemConfig::readyCmds },
  88. { "modemdialcmd", &ModemConfig::dialCmd, "ATDT%s" },
  89. { "modemsetorigincmd", &ModemConfig::setOriginCmd },
  90. { "modemnoflowcmd", &ModemConfig::noFlowCmd },
  91. { "modemsoftflowcmd", &ModemConfig::softFlowCmd },
  92. { "modemhardflowcmd", &ModemConfig::hardFlowCmd },
  93. { "modemsetupaacmd", &ModemConfig::setupAACmd },
  94. { "modemsetupdtrcmd", &ModemConfig::setupDTRCmd },
  95. { "modemsetupdcdcmd", &ModemConfig::setupDCDCmd },
  96. { "modemnoautoanswercmd", &ModemConfig::noAutoAnswerCmd, "ATS0=0" },
  97. { "modemechooffcmd", &ModemConfig::echoOffCmd, "ATE0" },
  98. { "modemverboseresultscmd", &ModemConfig::verboseResultsCmd,"ATV1" },
  99. { "modemresultcodescmd", &ModemConfig::resultCodesCmd, "ATQ0" },
  100. { "modemonhookcmd", &ModemConfig::onHookCmd, "ATH0" },
  101. { "modemsoftresetcmd", &ModemConfig::softResetCmd, "ATZ" },
  102. { "modemwaittimecmd", &ModemConfig::waitTimeCmd, "ATS7=60" },
  103. { "modemcommapausetimecmd", &ModemConfig::pauseTimeCmd, "ATS8=2" },
  104. { "modemmfrquerycmd", &ModemConfig::mfrQueryCmd },
  105. { "modemmodelquerycmd", &ModemConfig::modelQueryCmd },
  106. { "modemrevquerycmd", &ModemConfig::revQueryCmd },
  107. { "modemsendbegincmd", &ModemConfig::sendBeginCmd },
  108. { "modemrecvsuccesscmd", &ModemConfig::recvSuccessCmd },
  109. { "modemclassquerycmd", &ModemConfig::classQueryCmd, "AT+FCLASS=?" },
  110. { "class0cmd", &ModemConfig::class0Cmd, "AT+FCLASS=0" },
  111. { "class1cmd", &ModemConfig::class1Cmd },
  112. { "class1adaptrecvcmd", &ModemConfig::class1AdaptRecvCmd },
  113. { "class1enablev34cmd", &ModemConfig::class1EnableV34Cmd },
  114. { "class1nflocmd", &ModemConfig::class1NFLOCmd },
  115. { "class1sflocmd", &ModemConfig::class1SFLOCmd },
  116. { "class1hflocmd", &ModemConfig::class1HFLOCmd },
  117. { "class1ppmwaitcmd", &ModemConfig::class1PPMWaitCmd, "AT+FTS=7" },
  118. { "class1responsewaitcmd", &ModemConfig::class1ResponseWaitCmd, "" },
  119. { "class1rmquerycmd", &ModemConfig::class1RMQueryCmd, "AT+FRM=?" },
  120. { "class1tcfwaitcmd", &ModemConfig::class1TCFWaitCmd, "AT+FTS=7" },
  121. { "class1tmquerycmd", &ModemConfig::class1TMQueryCmd, "AT+FTM=?" },
  122. { "class1eopwaitcmd", &ModemConfig::class1EOPWaitCmd, "AT+FTS=9" },
  123. { "class1msgrecvhackcmd", &ModemConfig::class1MsgRecvHackCmd, "" },
  124. { "class1tcfrecvhackcmd", &ModemConfig::class1TCFRecvHackCmd, "" },
  125. { "class1switchingcmd", &ModemConfig::class1SwitchingCmd, "AT+FRS=7" },
  126. { "class2cmd", &ModemConfig::class2Cmd },
  127. { "class2borcmd", &ModemConfig::class2BORCmd },
  128. { "class2disablev17cmd", &ModemConfig::class2DisableV17Cmd },
  129. { "class2disablev34cmd", &ModemConfig::class2DisableV34Cmd },
  130. { "class2relcmd", &ModemConfig::class2RELCmd },
  131. { "class2cqcmd", &ModemConfig::class2CQCmd },
  132. { "class2abortcmd", &ModemConfig::class2AbortCmd },
  133. { "class2cqquerycmd",     &ModemConfig::class2CQQueryCmd, "AT+FCQ=?" },
  134. { "class2dccquerycmd", &ModemConfig::class2DCCQueryCmd },
  135. { "class2tbccmd", &ModemConfig::class2TBCCmd },
  136. { "class2crcmd", &ModemConfig::class2CRCmd },
  137. { "class2phctocmd", &ModemConfig::class2PHCTOCmd },
  138. { "class2bugcmd", &ModemConfig::class2BUGCmd },
  139. { "class2lidcmd", &ModemConfig::class2LIDCmd },
  140. { "class2dcccmd", &ModemConfig::class2DCCCmd },
  141. { "class2discmd", &ModemConfig::class2DISCmd },
  142. { "class2ddiscmd", &ModemConfig::class2DDISCmd },
  143. { "class2cigcmd", &ModemConfig::class2CIGCmd },
  144. { "class2ptscmd", &ModemConfig::class2PTSCmd },
  145. { "class2ptsquerycmd", &ModemConfig::class2PTSQueryCmd, "AT+FPS?" },
  146. { "class2splcmd", &ModemConfig::class2SPLCmd },
  147. { "class2piecmd", &ModemConfig::class2PIECmd },
  148. { "class2nrcmd", &ModemConfig::class2NRCmd },
  149. { "class2nflocmd", &ModemConfig::class2NFLOCmd },
  150. { "class2sflocmd", &ModemConfig::class2SFLOCmd },
  151. { "class2hflocmd", &ModemConfig::class2HFLOCmd },
  152. { "class2minspcmd", &ModemConfig::class2MINSPCmd },
  153. { "class2apquerycmd", &ModemConfig::class2APQueryCmd, "AT+FAP=?" },
  154. { "class2apcmd", &ModemConfig::class2APCmd, "AT+FAP" },
  155. { "class2sacmd", &ModemConfig::class2SACmd, "AT+FSA" },
  156. { "class2pacmd", &ModemConfig::class2PACmd, "AT+FPA" },
  157. { "class2pwcmd", &ModemConfig::class2PWCmd, "AT+FPW" },
  158. };
  159. static struct {
  160.     const char*  name;
  161.     fxStr ModemConfig::* p;
  162.     const char*  def; // NULL is shorthand for ""
  163. } strcmds[] = {
  164. { "modemtype", &ModemConfig::type, "unknown" },
  165. { "taglinefont", &ModemConfig::tagLineFontFile },
  166. { "taglinelocale", &ModemConfig::tagLineLocale, "" },
  167. { "taglineformat", &ModemConfig::tagLineFmt,
  168.   "From %%n|%c|Page %%p of %%t" },
  169. { "tiff2faxcmd", &ModemConfig::tiff2faxCmd, FAX_TIFF2FAXCMD },
  170. { "class2recvdatatrigger", &ModemConfig::class2RecvDataTrigger },
  171. { "ringdata", &ModemConfig::ringData },
  172. { "ringfax", &ModemConfig::ringFax },
  173. { "ringvoice", &ModemConfig::ringVoice },
  174. { "ringextended", &ModemConfig::ringExtended },
  175. { "dringon", &ModemConfig::dringOn  },
  176. { "dringoff", &ModemConfig::dringOff  },
  177. };
  178. static struct {
  179.     const char*  name;
  180.     u_int ModemConfig::* p;
  181.     u_int  def;
  182. } fillorders[] = {
  183. { "modemrecvfillorder",  &ModemConfig::recvFillOrder,  0 }, // will be autodetected
  184. { "modemsendfillorder",  &ModemConfig::sendFillOrder,  0 }, // will be autodetected
  185. { "modemframefillorder", &ModemConfig::frameFillOrder, FILLORDER_LSB2MSB },
  186. };
  187. static struct {
  188.     const char*  name;
  189.     u_int ModemConfig::* p;
  190.     u_int  def;
  191. } numbers[] = {
  192. { "ringtimeout", &ModemConfig::ringTimeout,      6000 },
  193. { "percentgoodlines", &ModemConfig::percentGoodLines,      95 },
  194. { "maxconsecutivebadlines", &ModemConfig::maxConsecutiveBadLines,5 },
  195. { "minacceptedlinecount", &ModemConfig::minAcceptedLineCount,  10 },
  196. { "modemresetdelay", &ModemConfig::resetDelay,      2600 },
  197. { "modemdtrdropdelay", &ModemConfig::dtrDropDelay,      75 },
  198. { "modembaudratedelay", &ModemConfig::baudRateDelay,      10 },
  199. { "modematcmddelay", &ModemConfig::atCmdDelay,      0 },
  200. { "faxt1timer", &ModemConfig::t1Timer,      TIMER_T1 },
  201. { "faxt2timer", &ModemConfig::t2Timer,      TIMER_T2 },
  202. { "faxt4timer", &ModemConfig::t4Timer,      TIMER_T4 },
  203. { "modemdialresponsetimeout", &ModemConfig::dialResponseTimeout,   3*60*1000},
  204. { "modemanswerresponsetimeout", &ModemConfig::answerResponseTimeout, 3*60*1000},
  205. { "modempagestarttimeout", &ModemConfig::pageStartTimeout,      3*60*1000},
  206. { "modempagedonetimeout", &ModemConfig::pageDoneTimeout,      3*60*1000},
  207. { "modemringsbeforeresponse", &ModemConfig::ringsBeforeResponse,   0 },
  208. { "modemsoftresetcmddelay", &ModemConfig::softResetCmdDelay,     3000 },
  209. { "modemnoautoanswercmddelay", &ModemConfig::noAutoAnswerCmdDelay,  0 },
  210. { "class1tcfrecvtimeout", &ModemConfig::class1TCFRecvTimeout,  4500 },
  211. { "class1recvabortok", &ModemConfig::class1RecvAbortOK,     200 },
  212. { "class1rmpersistence", &ModemConfig::class1RMPersistence,   2 },
  213. { "class1hooksensitivity", &ModemConfig::class1HookSensitivity, 0 },
  214. { "class1frameoverhead", &ModemConfig::class1FrameOverhead,   4 },
  215. { "class1recvidenttimer", &ModemConfig::class1RecvIdentTimer,  TIMER_T1 },
  216. { "class1tcfmaxnonzero", &ModemConfig::class1TCFMaxNonZero,   10 },
  217. { "class1tcfminrun", &ModemConfig::class1TCFMinRun,       (2*TCF_DURATION)/3 },
  218. { "class1tcfminrunecmmod", &ModemConfig::class1TCFMinRunECMMod, 2 },
  219. { "class1tmconnectdelay", &ModemConfig::class1TMConnectDelay,  0 },
  220. { "class1ecmframesize", &ModemConfig::class1ECMFrameSize,    256 },
  221. { "class1pagelengthsupport", &ModemConfig::class1PageLengthSupport, LN_ALL },
  222. { "class1pagewidthsupport", &ModemConfig::class1PageWidthSupport, WD_ALL },
  223. };
  224. static struct {
  225.     const char*  name;
  226.     bool ModemConfig::* p;
  227.     bool  def;
  228. } booleans[] = {
  229. { "usejobtagline", &ModemConfig::useJobTagLine, true },
  230. { "modemwaitforconnect", &ModemConfig::useJobTagLine, false },
  231. { "modemraiseatcommands", &ModemConfig::raiseATCmd, true },
  232. { "class2xmitwaitforxon", &ModemConfig::class2XmitWaitForXON, true },
  233. { "class2sendrtc", &ModemConfig::class2SendRTC, false },
  234. { "class2rtfcc", &ModemConfig::class2RTFCC, false },
  235. { "class2usehex", &ModemConfig::class2UseHex, false },
  236. { "class2hexnsf", &ModemConfig::class2HexNSF, true },
  237. { "class2uselinecount", &ModemConfig::class2UseLineCount, false },
  238. #ifdef PHOTOMETRIC_ITULAB
  239. { "class1greyjpegsupport", &ModemConfig::class1GreyJPEGSupport, false },
  240. { "class1colorjpegsupport", &ModemConfig::class1ColorJPEGSupport, false },
  241. { "class2jpegsupport", &ModemConfig::class2JPEGSupport, false },
  242. #endif
  243. { "class1ecmsupport", &ModemConfig::class1ECMSupport, true },
  244. { "class1mrsupport", &ModemConfig::class1MRSupport, true },
  245. { "class1mmrsupport", &ModemConfig::class1MMRSupport, true },
  246. { "class1persistentecm", &ModemConfig::class1PersistentECM, true },
  247. { "class1validatev21frames", &ModemConfig::class1ValidateV21Frames, false },
  248. { "class1modemhasdlebug", &ModemConfig::class1ModemHasDLEBug, false },
  249. { "class1hasrhconnectbug", &ModemConfig::class1HasRHConnectBug, false },
  250. { "saveunconfirmedpages", &ModemConfig::saveUnconfirmedPages, true },
  251. { "modemsoftrtfcc", &ModemConfig::softRTFCC, true },
  252. { "modemdophasecdebug", &ModemConfig::doPhaseCDebug, false },
  253. { "noanswervoice", &ModemConfig::noAnswerVoice, false },
  254. { "saverawimage", &ModemConfig::saverawimage, false },
  255. };
  257. void
  258. ModemConfig::setupConfig()
  259. {
  260.     int i;
  262.     for (i = N(atcmds)-1; i >= 0; i--)
  263. (*this).*atcmds[i].p = (atcmds[i].def ? atcmds[i].def : "");
  264.     for (i = N(strcmds)-1; i >= 0; i--)
  265. (*this).*strcmds[i].p = (strcmds[i].def ? strcmds[i].def : "");
  266.     for (i = N(fillorders)-1; i >= 0; i--)
  267. (*this).*fillorders[i].p = fillorders[i].def;
  268.     for (i = N(numbers)-1; i >= 0; i--)
  269. (*this).*numbers[i].p = numbers[i].def;
  270.     for (i = N(booleans)-1; i >= 0; i--)
  271. (*this).*booleans[i].p = booleans[i].def;
  273.     for (i=0; i < 5; ++i) {
  274.      distinctiveRings[i].type = ClassModem::CALLTYPE_UNKNOWN;
  275. for (u_int j=0; j < 5; ++j)
  276.     distinctiveRings[i].cadence[j] = 0;
  277. distinctiveRings[i].magsqrd = 0;
  278.     }
  280.     flowControl         = ClassModem::FLOW_XONXOFF;// software flow control
  281.     maxRate = ClassModem::BR19200; // reasonable for most modems
  282.     minSpeed = BR_2400; // minimum transmit speed
  283.     class2ECMType = ClassModem::ECMTYPE_UNSET;// follow the service type default
  284. #ifdef HAVE_JBIG
  285. #ifdef HAVE_JBIGTIFF
  286.     class1JBIGSupport = FaxModem::JBIG_FULL; // full support for monochrome JBIG
  287.     class2JBIGSupport = FaxModem::JBIG_FULL; // full support for monochrome JBIG
  288. #else
  289.     class1JBIGSupport = FaxModem::JBIG_SEND; // send support for monochrome JBIG
  290.     class2JBIGSupport = FaxModem::JBIG_SEND; // send support for monochrome JBIG
  291. #endif
  292. #else
  293. #ifdef HAVE_JBIGTIFF
  294.     class1JBIGSupport = FaxModem::JBIG_RECV; // receive support for monochrome JBIG
  295.     class2JBIGSupport = FaxModem::JBIG_RECV; // receive support for monochrome JBIG
  296. #else
  297.     class1JBIGSupport = FaxModem::JBIG_NONE; // no support for monochrome JBIG
  298.     class2JBIGSupport = FaxModem::JBIG_NONE; // no support for monochrome JBIG
  299. #endif
  300. #endif
  301.     class1Resolutions = VR_ALL; // resolutions support
  302.     setVolumeCmds("ATM0 ATL0M1 ATL1M1 ATL2M1 ATL3M1");
  303.     recvDataFormat = DF_ALL; // default to no transcoding
  304.     rtnHandling         = FaxModem::RTN_RETRANSMITIGNORE; // retransmit until MCF/MPS
  305.     badPageHandling = FaxModem::BADPAGE_RTNSAVE; // send RTN but save the page
  307.     idConfig.resize(0);
  308.     callidIndex = (u_int) -1;
  309. }
  311. void
  312. ModemConfig::resetConfig()
  313. {
  314.     FaxConfig::resetConfig();
  315.     setupConfig();
  316. }
  318. #define valeq(a,b) (strcasecmp(a,b)==0)
  320. bool
  321. ModemConfig::findRate(const char* cp, BaudRate& br)
  322. {
  323.     static const struct {
  324. const char* name;
  325. BaudRate    b;
  326.     } rates[] = {
  327. {    "300", ClassModem::BR300 },
  328. {   "1200", ClassModem::BR1200 },
  329. {   "2400", ClassModem::BR2400 },
  330. {   "4800", ClassModem::BR4800 },
  331. {   "9600", ClassModem::BR9600 },
  332. {  "19200", ClassModem::BR19200 },
  333. {  "38400", ClassModem::BR38400 },
  334. {  "57600", ClassModem::BR57600 },
  335. {  "76800", ClassModem::BR76800 },
  336. { "115200", ClassModem::BR115200 },
  337.     };
  338.     for (int i = N(rates)-1; i >= 0; i--)
  339. if (streq(cp, rates[i].name)) {
  340.     br = rates[i].b;
  341.     return (true);
  342. }
  343.     return (false);
  344. }
  346. BaudRate
  347. ModemConfig::getRate(const char* cp)
  348. {
  349.     BaudRate br;
  350.     if (!findRate(cp, br)) {
  351. configError("Unknown baud rate "%s", using 19200", cp);
  352. br = ClassModem::BR19200; // default
  353.     }
  354.     return (br);
  355. }
  357. ECMType
  358. ModemConfig::getECMType(const char* cp)
  359. {
  360.     if (valeq(cp, "2"))
  361. return (ClassModem::ECMTYPE_CLASS2);
  362.     if (valeq(cp, "2.0"))
  363. return (ClassModem::ECMTYPE_CLASS20);
  364.     configError("Unknown ECM type specification "%s", using default", cp);
  365.     return (ClassModem::ECMTYPE_UNSET);
  366. }
  368. bool
  369. ModemConfig::findATResponse(const char* cp, ATResponse& resp)
  370. {
  371.     static const struct {
  372. const char* name;
  373. ATResponse  r;
  374.     } responses[] = {
  375. {    "NOTHING", ClassModem::AT_NOTHING },
  376. {         "OK", ClassModem::AT_OK },
  377. {    "CONNECT", ClassModem::AT_CONNECT },
  378. {   "NOANSWER", ClassModem::AT_NOANSWER },
  379. {  "NOCARRIER", ClassModem::AT_NOCARRIER },
  380. { "NODIALTONE", ClassModem::AT_NODIALTONE },
  381. {       "BUSY", ClassModem::AT_BUSY },
  382. {    "OFFHOOK", ClassModem::AT_OFFHOOK },
  383. {       "RING", ClassModem::AT_RING },
  384. {      "ERROR", ClassModem::AT_ERROR },
  385. {       "VCON", ClassModem::AT_VCON },
  386. {      "OTHER", ClassModem::AT_OTHER },
  387.     };
  388.     for (u_int i = 0; i < N(responses); i++)
  389. if (valeq(cp, responses[i].name)) {
  390.     resp = responses[i].r;
  391.     return (true);
  392. }
  393.     return (false);
  394. }
  396. u_int
  397. ModemConfig::getFill(const char* cp)
  398. {
  399.     if (valeq(cp, "LSB2MSB"))
  400. return (FILLORDER_LSB2MSB);
  401.     else if (valeq(cp, "MSB2LSB"))
  402. return (FILLORDER_MSB2LSB);
  403.     else {
  404. configError("Unknown fill order "%s"", cp);
  405.         return ((u_int) -1);
  406.     }
  407. }
  409. bool
  410. ModemConfig::findFlow(const char* cp, FlowControl& fc)
  411. {
  412.     static const struct {
  413. const char* name;
  414. FlowControl f;
  415.     } fcnames[] = {
  416. { "XONXOFF", ClassModem::FLOW_XONXOFF },
  417. {  "RTSCTS", ClassModem::FLOW_RTSCTS },
  418. {    "NONE", ClassModem::FLOW_NONE },
  419. {     "XON", ClassModem::FLOW_XONXOFF },
  420. {     "RTS", ClassModem::FLOW_RTSCTS },
  421.     };
  422.     for (u_int i = 0; i < N(fcnames); i++)
  423. if (valeq(cp, fcnames[i].name)) {
  424.     fc = fcnames[i].f;
  425.     return (true);
  426. }
  427.     return (false);
  428. }
  430. FlowControl
  431. ModemConfig::getFlow(const char* cp)
  432. {
  433.     FlowControl fc;
  434.     if (!findFlow(cp, fc)) {
  435. configError("Unknown flow control "%s", using xonxoff", cp);
  436. fc = ClassModem::FLOW_XONXOFF; // default
  437.     }
  438.     return (fc);
  439. }
  441. void
  442. ModemConfig::setVolumeCmds(const fxStr& tag)
  443. {
  444.     u_int l = 0;
  445.     for (int i = ClassModem::OFF; i <= ClassModem::HIGH; i++)
  446. setVolumeCmd[i] = parseATCmd(tag.token(l, " t"));
  447. }
  449. /*
  450.  * Scan AT command strings and convert <...> escape
  451.  * commands into single-byte escape codes that are
  452.  * interpreted by ClassModem::atCmd.  Note that the
  453.  * baud rate setting commands are carefully ordered
  454.  * so that the desired baud rate can be extracted
  455.  * from the low nibble.
  456.  */
  457. fxStr
  458. ModemConfig::parseATCmd(const char* cp)
  459. {
  460.     fxStr cmd(cp);
  461.     u_int pos = 0;
  462.     while ((pos = cmd.next(pos, '<')) != cmd.length()) {
  463. u_int epos = pos+1;
  464. fxStr esc = cmd.token(epos, '>');
  465. esc.lowercase();
  467. FlowControl fc;
  468. BaudRate br;
  469. u_char ecode[2];
  470. if (findFlow(esc, fc)) {
  471.     ecode[0] = ESC_SETFLOW;
  472.     ecode[1] = (u_char) fc;
  473. } else if (findRate(esc, br)) {
  474.     ecode[0] = ESC_SETBR;
  475.     ecode[1] = (u_char) br;
  476. } else if (esc == "flush") {
  477.     cmd.remove(pos, epos-pos);
  478.     cmd.insert(ESC_FLUSH, pos);
  479.     continue;
  480. } else if (esc == "") { // NB: "<>" => <
  481.     cmd.remove(pos, epos-pos);
  482.     cmd.insert('<', pos);
  483.     continue;
  484. } else if (esc.length() > 6 && strneq(esc, "delay:", 6)) {
  485.     u_int delay = (u_int) atoi(&esc[6]);
  486.     if (delay > 255) {
  487. configError("Bad AT delay value "%s", must be <256", &esc[6]);
  488. pos = epos;
  489. continue;
  490.     }
  491.     ecode[0] = ESC_DELAY;
  492.     ecode[1] = (u_char) delay;
  493. } else if (esc.length() > 8 && strneq(esc, "waitfor:", 8)) {
  494.     ATResponse resp;
  495.     if (!findATResponse(&esc[8], resp)) {
  496. configError("Unknown AT response code "%s"", &esc[8]);
  497. pos = epos;
  498. continue;
  499.     }
  500.     ecode[0] = ESC_WAITFOR;
  501.     ecode[1] = (u_char) resp;
  502. } else if (esc.length() > 5 && strneq(esc, "play:", 5)) {
  503.     ecode[0] = ESC_PLAY;
  504.     ecode[1] = (u_char) esc[5];
  505. } else {
  506.     configError("Unknown AT escape code "%s"", (const char*) esc);
  507.     pos = epos;
  508.     continue;
  509. }
  510. cmd.remove(pos, epos-pos);
  511. cmd.insert((char*) ecode, pos, 2);
  512. pos += 2; // don't try parsing our newly inserted ecode
  513.     }
  514.     return (cmd);
  515. }
  517. u_int
  518. ModemConfig::getSpeed(const char* value)
  519. {
  520.     switch (atoi(value)) {
  521.     case 2400: return (BR_2400);
  522.     case 4800: return (BR_4800);
  523.     case 7200: return (BR_7200);
  524.     case 9600: return (BR_9600);
  525.     case 12000: return (BR_12000);
  526.     case 14400: return (BR_14400);
  527.     case 16800: return (BR_16800);
  528.     case 19200: return (BR_19200);
  529.     case 21600: return (BR_21600);
  530.     case 24000: return (BR_24000);
  531.     case 26400: return (BR_26400);
  532.     case 28800: return (BR_28800);
  533.     case 31200: return (BR_31200);
  534.     case 33600: return (BR_33600);
  535.     }
  536.     configError("Invalid minimum transmit speed "%s"", value);
  537.     return (BR_2400);
  538. }
  540. bool
  541. ModemConfig::findDataFormat(const char* cp, u_int& df)
  542. {
  543.     static const struct {
  544. const char* name;
  545. u_int d;
  546.     } dfnames[] = {
  547. {       "1DMH", DF_1DMH },
  548. {       "2DMR", DF_2DMR },
  549. { "2DMRUNCOMP", DF_2DMRUNCOMP },
  550. {      "2DMMR", DF_2DMMR },
  551. {   "adaptive", DF_ALL },
  552.     };
  553.     char v[30];
  554.     u_int i = 0;
  555.     for (; *cp; cp++) {
  556. if (*cp == '-' || isspace(*cp)) // strip ``-'' and white space
  557.     continue;
  558. if (i >= sizeof (v))
  559.     break;
  560. v[i++] = *cp;
  561.     }
  562.     v[i] = '';
  563.     for (i = 0; i < N(dfnames); i++)
  564. if (valeq(v, dfnames[i].name)) {
  565.     df = dfnames[i].d;
  566.     return (true);
  567. }
  568.     return (false);
  569. }
  571. u_int
  572. ModemConfig::getDataFormat(const char* cp)
  573. {
  574.     u_int df;
  575.     if (!findDataFormat(cp, df)) {
  576. configError("Unknown data format "%s", disabling transcoding", cp);
  577. df = DF_ALL; // default
  578.     }
  579.     return (df);
  580. }
  582. bool
  583. ModemConfig::findRTNHandling(const char* cp, RTNHandling& rh)
  584. {
  585.     static const struct {
  586.         const char* name;
  587.         RTNHandling rh;
  588.     } rhnames[] = {
  589.         { "RETRANSMIT", FaxModem::RTN_RETRANSMIT },
  590.         {     "GIVEUP", FaxModem::RTN_GIVEUP },
  591.         {     "IGNORE", FaxModem::RTN_IGNORE },
  592.         { "RETRANSMIT-IGNORE", FaxModem::RTN_RETRANSMITIGNORE }
  593.     };
  594.     for (u_int i = 0; i < N(rhnames); i++)
  595.         if (valeq(cp, rhnames[i].name)) {
  596.             rh = rhnames[i].rh;
  597.             return (true);
  598.         }
  599.     return (false);
  600. }
  602. u_int
  603. ModemConfig::getRTNHandling(const char* cp)
  604. {
  605.     RTNHandling rh;
  606.     if (!findRTNHandling(cp, rh)) {
  607.         configError("Unknown RTN handling method "%s", using RETRANSMIT-IGNORE", cp);
  608.         rh = FaxModem::RTN_RETRANSMITIGNORE;   // default
  609.     }
  610.     return (rh);
  611. }
  613. u_int
  614. ModemConfig::getBadPageHandling(const char* cp)
  615. {
  616.     BadPageHandling bph;
  617.     if (valeq(cp, "RTN")) {
  618. bph = FaxModem::BADPAGE_RTN;
  619.     } else if (valeq(cp, "DCN")) {
  620. bph = FaxModem::BADPAGE_DCN;
  621.     } else {
  622. bph = FaxModem::BADPAGE_RTNSAVE;
  623.     }
  624.     return (bph);
  625. }
  627. u_int
  628. ModemConfig::getJBIGSupport(const char* cp)
  629. {
  630.     JBIGSupport js;
  631.     if (valeq(cp, "FULL")) {
  632. js = FaxModem::JBIG_FULL;
  633.     } else if (valeq(cp, "YES")) {
  634. js = FaxModem::JBIG_FULL;
  635.     } else if (valeq(cp, "TRUE")) {
  636. js = FaxModem::JBIG_FULL;
  637.     } else if (valeq(cp, "NONE")) {
  638. js = FaxModem::JBIG_NONE;
  639.     } else if (valeq(cp, "NO")) {
  640. js = FaxModem::JBIG_NONE;
  641.     } else if (valeq(cp, "FALSE")) {
  642. js = FaxModem::JBIG_NONE;
  643.     } else if (valeq(cp, "SEND")) {
  644. js = FaxModem::JBIG_SEND;
  645.     } else if (valeq(cp, "RECEIVE")) {
  646. js = FaxModem::JBIG_RECV;
  647.     } else if (valeq(cp, "RECV")) {
  648. js = FaxModem::JBIG_RECV;
  649.     } else {
  650. #ifdef HAVE_JBIG
  651. #ifdef HAVE_JBIGTIFF
  652. js = FaxModem::JBIG_FULL;
  653. #else
  654. js = FaxModem::JBIG_SEND;
  655. #endif
  656. #else
  657. #ifdef HAVE_JBIGTIFF
  658. js = FaxModem::JBIG_RECV;
  659. #else
  660. js = FaxModem::JBIG_NONE;
  661. #endif
  662. #endif
  663.     }
  664.     return (js);
  665. }
  667. void
  668. ModemConfig::parseCallID(const char* rbuf, CallID& callid) const
  669. {
  670.     for (size_t i = 0; i < idConfig.length(); i++) {
  671. fxAssert(i < callid.size(), "Miss matched Call ID Size with parsing");
  672. const fxStr& pat = idConfig[i].pattern;
  673. if (pat.length() && strneq(rbuf, pat, pat.length()))
  674.     callid[i].append(rbuf+pat.length());
  675.     }
  676. }
  678. void
  679. ModemConfig::parseDR(const char* cin)
  680. {
  681.     if (strlen(cin) < 3) return;
  682.     char buf[2048];
  683.     strncpy(buf, cin, sizeof (buf));
  684.     char* cp = buf;
  685.     u_int i = 0;
  686.     char* cp1 = cp;
  687.     while (*cp++) {
  688.      if (*cp == ',') {
  689. *cp = '';                     // Nuke the ','
  690. processDRString(cp1, i++);
  691. cp1 = ++cp;
  692. }
  693.     }
  694.     processDRString(cp1, i);
  695.     NoDRings = i + 1;
  696. }
  698. void
  699. ModemConfig::processDRString(char* cp, const u_int i)
  700. {
  701.     if (*cp == 'V')
  702.      distinctiveRings[i].type = ClassModem::CALLTYPE_VOICE;
  703.     else if (*cp == 'F')
  704.      distinctiveRings[i].type = ClassModem::CALLTYPE_FAX;
  705.     else if (*cp == 'D')
  706.      distinctiveRings[i].type = ClassModem::CALLTYPE_DATA;
  708.     while (*cp != '-'){ cp++;}
  709.     *cp = '';
  710.     u_int j = 0;
  711.     int sign = 1;
  712.     char *cp1 = cp += 1;
  713.     while (*cp++) {
  714.      if (*cp == '-') {
  715.     *cp = '';                             // Nuke the '-'
  716.          distinctiveRings[i].cadence[j++] = sign*atoi(cp1);
  717.     sign = -sign;
  718.     cp1 = ++cp;
  719. }
  720.     }
  721.     distinctiveRings[i].cadence[j] =  sign*atoi(cp1);
  723.     double sum = 0;
  724.     for ( u_int k=0; k < 5; ++k ) 
  725.         sum += distinctiveRings[i].cadence[k]*distinctiveRings[i].cadence[k];
  726.     distinctiveRings[i].magsqrd = sum;
  727. }
  729. bool
  730. ModemConfig::setConfigItem(const char* tag, const char* value)
  731. {
  732.     u_int ix;
  733.     if (findTag(tag, (const tags*)atcmds, N(atcmds), ix))
  734. (*this).*atcmds[ix].p = parseATCmd(value);
  735.     else if (findTag(tag, (const tags*)strcmds, N(strcmds), ix))
  736. (*this).*strcmds[ix].p = value;
  737.     else if (findTag(tag, (const tags*)fillorders, N(fillorders), ix))
  738. (*this).*fillorders[ix].p = getFill(value);
  739.     else if (findTag(tag, (const tags*)numbers, N(numbers), ix))
  740. (*this).*numbers[ix].p = atoi(value);
  741.     else if (findTag(tag, (const tags*)booleans, N(booleans), ix))
  742. (*this).*booleans[ix].p = getBoolean(value);
  744.     else if (streq(tag, "modemsetvolumecmd"))
  745. setVolumeCmds(value);
  746.     else if (streq(tag, "modemflowcontrol"))
  747. flowControl = getFlow(value);
  748.     else if (streq(tag, "modemrate"))
  749. maxRate = getRate(value);
  750.     else if (streq(tag, "class1jbigsupport"))
  751.         class1JBIGSupport = getJBIGSupport(value);
  752.     else if (streq(tag, "class2jbigsupport"))
  753.         class2JBIGSupport = getJBIGSupport(value);
  754.     else if (streq(tag, "class1extendedres"))
  755. class1Resolutions = getBoolean(value) ? VR_ALL : (VR_NORMAL | VR_FINE);
  756.     else if (streq(tag, "class1resolutions"))
  757. class1Resolutions = getNumber(value);
  758.     else if (streq(tag, "class1tcfrecvhack") && getBoolean(value))
  759. class1TCFRecvHackCmd = "AT+FRS=1"; // backwards compatibility
  760.     else if (streq(tag, "modemminspeed"))
  761. minSpeed = getSpeed(value);
  762.     else if (streq(tag, "recvdataformat"))
  763. recvDataFormat = getDataFormat(value);
  764.     else if (streq(tag, "rtnhandlingmethod"))
  765.         rtnHandling = getRTNHandling(value);
  766.     else if (streq(tag, "badpagehandlingmethod"))
  767.         badPageHandling = getBadPageHandling(value);
  768.     else if (streq(tag, "class2ecmtype"))
  769. class2ECMType = getECMType(value);
  770.     else if (streq(tag, "distinctiverings"))
  771.      parseDR(value);
  772.     else if (streq(tag, "callidpattern") || streq(tag, "callidanswerlength") || streq(tag, "calliddisplay") 
  773.      || streq(tag, "callidlabel") || streq(tag, "callidrecord") || streq(tag, "callidtype")) {
  774. if (tag[6] == 'p') callidIndex++; // only increment on instances of "Pattern"
  775. if (idConfig.length() < callidIndex+1 && callidIndex != (u_int) -1)
  776.     idConfig.resize(callidIndex+1);
  777. if (tag[6] == 'p') {
  778.     idConfig[callidIndex].answerlength = 0; // we must initialize this
  779.     idConfig[callidIndex].display = false; // we must initialize this
  780.     idConfig[callidIndex].record = true; // we must initialize this
  781.     idConfig[callidIndex].label = ""; // we must initialize this
  782.     idConfig[callidIndex].type = ""; // we must initialize this
  783.     idConfig[callidIndex].pattern = value;
  784.     configTrace("CallID[%d].pattern = "%s"", callidIndex,
  785.     (const char*)idConfig[callidIndex].pattern);
  786. } else {
  787.     if (callidIndex != (u_int) -1) {
  788. switch (tag[6]) {
  789.     case 'a':
  790. idConfig[callidIndex].answerlength = atoi(value);
  791. configTrace("CallID[%d].answerlength = %d", callidIndex,
  792.     idConfig[callidIndex].answerlength);
  793. break;
  794.     case 'd':
  795. idConfig[callidIndex].display = getBoolean(value);
  796. configTrace("CallID[%d].display = %s", callidIndex,
  797.     idConfig[callidIndex].display ? "true" : "false");
  798. break;
  799.     case 'r':
  800. idConfig[callidIndex].record = getBoolean(value);
  801. configTrace("CallID[%d].record = %s", callidIndex,
  802.     idConfig[callidIndex].record ? "true" : "false");
  803. break;
  804.     case 'l':
  805. idConfig[callidIndex].label = value;
  806. configTrace("CallID[%d].label = "%s"", callidIndex,
  807.     (const char*) idConfig[callidIndex].label);
  808. break;
  809.     case 't':
  810. idConfig[callidIndex].type = value;
  811. configTrace("CallID[%d].type = "%s"", callidIndex,
  812.     (const char*) idConfig[callidIndex].type);
  813. break;
  814. }
  815.     } else
  816. configError("No index for Call ID attribute");
  817. }
  818.     } else if (streq(tag, "cidnumber")) {
  819. if (idConfig.length() < CallID::NUMBER+1)
  820.     idConfig.resize(CallID::NUMBER+1);
  821. idConfig[CallID::NUMBER].pattern = value;
  822. idConfig[CallID::NUMBER].answerlength = 0; // we must initialize this
  823. idConfig[CallID::NUMBER].display = false; // we must initialize this
  824. idConfig[CallID::NUMBER].record = true; // we must initialize this
  825. idConfig[CallID::NUMBER].label = ""; // we must initialize this
  826. idConfig[CallID::NUMBER].type = ""; // we must initialize this
  827.     } else if (streq(tag, "cidname")) {
  828. if (idConfig.length() < CallID::NAME+1)
  829.     idConfig.resize(CallID::NAME+1);
  830. idConfig[CallID::NAME].pattern = value;
  831. idConfig[CallID::NAME].answerlength = 0; // we must initialize this
  832. idConfig[CallID::NAME].display = false; // we must initialize this
  833. idConfig[CallID::NAME].record = true; // we must initialize this
  834. idConfig[CallID::NAME].label = ""; // we must initialize this
  835. idConfig[CallID::NAME].type = ""; // we must initialize this
  836.     } else if (streq(tag, "cidnumberanswerlength")) {
  837. if (idConfig.length() < CallID::NUMBER+1)
  838.     idConfig.resize(CallID::NUMBER+1);
  839. idConfig[CallID::NUMBER].answerlength = getNumber(value);
  840.     } else if (streq(tag, "cidnameanswerlength")) {
  841. if (idConfig.length() < CallID::NAME+1)
  842.     idConfig.resize(CallID::NAME+1);
  843. idConfig[CallID::NAME].answerlength = getNumber(value);
  844.     } else
  845. return (false);
  846.     return (true);
  847. }
  848. #undef N
  850. fxIMPLEMENT_ObjArray(IDConfArray, id_config);