c:/Git/PeerCast.root/PeerCast/core/common/peercast.cpp

   1 #include "sys.h"
   2 #include "peercast.h"
   3 #include "channel.h"
   4 #include "servmgr.h"
   5 #ifdef _DEBUG
   6 #include "chkMemoryLeak.h"
   7 #define DEBUG_NEW new(__FILE__, __LINE__)
   8 #define new DEBUG_NEW
   9 #endif
  10
  11 #include "version2.h"
  12
  13 // ---------------------------------
  14 // globals
  15
  16 Sys *sys=NULL;
  17 ChanMgr *chanMgr;
  18 ServMgr *servMgr;
  19
  20 PeercastInstance *peercastInst=NULL;
  21 PeercastApplication *peercastApp=NULL;
  22
  23 int version_ex = 0;
  24
  25 // ---------------------------------
  26 void APICALL PeercastInstance::init()
  27 {
  28         sys = createSys();
  29         servMgr = new ServMgr();
  30         chanMgr = new ChanMgr();
  31
  32         if (peercastApp->getIniFilename())
  33                 servMgr->loadSettings(peercastApp->getIniFilename());
  34
  35         servMgr->start();
  36 }
  37 // --------------------------------------------------
  38 void    APICALL PeercastInstance::setNotifyMask(int mask)
  39 {
  40         if (servMgr)
  41                 servMgr->notifyMask = mask;
  42 }
  43 // --------------------------------------------------
  44 int             APICALL PeercastInstance::getNotifyMask()
  45 {
  46         if (servMgr)
  47                 return servMgr->notifyMask;
  48         else
  49                 return 0;
  50 }
  51
  52 // --------------------------------------------------
  53 void    APICALL PeercastInstance::setAutoConnect(bool on)
  54 {
  55         if (servMgr)
  56                 servMgr->autoConnect = on;
  57 }
  58 // --------------------------------------------------
  59 bool    APICALL PeercastInstance::getAutoConnect()
  60 {
  61         if (servMgr)
  62                 return servMgr->autoConnect;
  63         else
  64                 return false;
  65 }
  66 // --------------------------------------------------
  67 void    APICALL PeercastInstance::setMaxOutput(int kbps)
  68 {
  69         if (servMgr)
  70                 servMgr->maxBitrateOut = kbps;
  71 }
  72 // --------------------------------------------------
  73 int             APICALL PeercastInstance::getMaxOutput()
  74 {
  75         if (servMgr)
  76                 return servMgr->maxBitrateOut;
  77         else
  78                 return 0;
  79 }
  80 // --------------------------------------------------
  81 void    APICALL PeercastInstance::setMaxRelays(int max)
  82 {
  83         if (servMgr)
  84                 servMgr->setMaxRelays(max);
  85 }
  86 // --------------------------------------------------
  87 int             APICALL PeercastInstance::getMaxRelays()
  88 {
  89         if (servMgr)
  90                 return servMgr->maxRelays;
  91         else
  92                 return 0;
  93 }
  94 // --------------------------------------------------
  95 void    APICALL PeercastInstance::setActive(bool on)
  96 {
  97         if (servMgr)
  98         {
  99                 servMgr->autoConnect = on;
 100                 servMgr->autoServe = on;
 101         }
 102 }
 103 // --------------------------------------------------
 104 bool    APICALL PeercastInstance::getActive()
 105 {
 106         if (servMgr)
 107                 return servMgr->autoConnect&&servMgr->autoServe;
 108         else
 109                 return false;
 110 }
 111 // --------------------------------------------------
 112 void    APICALL PeercastInstance::saveSettings()
 113 {
 114         if (servMgr)
 115                 servMgr->saveSettings(peercastApp->getIniFilename());
 116 }
 117 // --------------------------------------------------
 118 void    APICALL PeercastInstance::quit()
 119 {
 120         isQuitting = true;
 121         if (chanMgr)
 122                 chanMgr->quit();
 123         if (servMgr)
 124                 servMgr->quit();
 125 }
 126 // --------------------------------------------------
 127 void    APICALL PeercastInstance::setServerPort(int port)
 128 {
 129         if (servMgr)
 130         {
 131                 servMgr->serverHost.port = port;
 132                 servMgr->restartServer = true;
 133         }
 134 }
 135 // --------------------------------------------------
 136 int             APICALL PeercastInstance::getServerPort()
 137 {
 138         if (servMgr)
 139                 return servMgr->serverHost.port;
 140         else
 141                 return 0;
 142 }
 143 // --------------------------------------------------
 144 void    APICALL PeercastInstance::setServerPassword(const char *pwd)
 145 {
 146         if (servMgr)
 147                 strcpy(servMgr->password,pwd);
 148 }
 149 // --------------------------------------------------
 150 const char *APICALL     PeercastInstance::getServerPassword()
 151 {
 152         return servMgr->password;
 153 }
 154 // --------------------------------------------------
 155 void    APICALL PeercastInstance::callLocalURL(const char *url)
 156 {
 157         if (sys && servMgr)
 158                 sys->callLocalURL(url,servMgr->serverHost.port);
 159 }
 160
 161
 162 // --------------------------------------------------
 163 void ADDLOG(const char *fmt,va_list ap,LogBuffer::TYPE type)
 164 {
 165         if(sys)
 166         {
 167                 const int MAX_LINELEN = 1024;
 168
 169                 char str[MAX_LINELEN+1];
 170                 vsnprintf(str,MAX_LINELEN-1,fmt,ap);
 171                 str[MAX_LINELEN-1]=0;
 172
 173                 if (type != LogBuffer::T_NONE)
 174                         sys->logBuf->write(str,type);
 175
 176                 peercastApp->printLog(type,str);
 177         }
 178 }
 179 // --------------------------------------------------
 180 void LOG(const char *fmt,...)
 181 {
 182         va_list ap;
 183         va_start(ap, fmt);
 184         ADDLOG(fmt,ap,LogBuffer::T_DEBUG);
 185         va_end(ap);
 186 }
 187
 188 // --------------------------------------------------
 189 void LOG_ERROR(const char *fmt,...)
 190 {
 191         if (servMgr)
 192         {
 193                 if ((servMgr->showLog & (1<<LogBuffer::T_ERROR)) && (!servMgr->pauseLog))
 194                 {
 195                         va_list ap;
 196                         va_start(ap, fmt);
 197                         ADDLOG(fmt,ap,LogBuffer::T_ERROR);
 198                         va_end(ap);
 199                 }
 200         }
 201 }
 202 // --------------------------------------------------
 203 void LOG_DEBUG(const char *fmt,...)
 204 {
 205         if (servMgr)
 206         {
 207                 if ((servMgr->showLog & (1<<LogBuffer::T_DEBUG)) && (!servMgr->pauseLog))
 208                 {
 209                         va_list ap;
 210                         va_start(ap, fmt);
 211                         ADDLOG(fmt,ap,LogBuffer::T_DEBUG);
 212                         va_end(ap);
 213                 }
 214         }
 215 }
 216 // --------------------------------------------------
 217 void LOG_NETWORK(const char *fmt,...)
 218 {
 219         if (servMgr)
 220         {
 221                 if ((servMgr->showLog & (1<<LogBuffer::T_NETWORK)) && (!servMgr->pauseLog))
 222                 {
 223                         va_list ap;
 224                         va_start(ap, fmt);
 225                         ADDLOG(fmt,ap,LogBuffer::T_NETWORK);
 226                         va_end(ap);
 227                 }
 228         }
 229 }
 230 // --------------------------------------------------
 231 void LOG_CHANNEL(const char *fmt,...)
 232 {
 233         if (servMgr)
 234         {
 235                 if ((servMgr->showLog & (1<<LogBuffer::T_CHANNEL)) && (!servMgr->pauseLog))
 236                 {
 237                         va_list ap;
 238                         va_start(ap, fmt);
 239                         ADDLOG(fmt,ap,LogBuffer::T_CHANNEL);
 240                         va_end(ap);
 241                 }
 242         }
 243 }