more eol-style
[xonotic/netradiant.git] / libs / synapse / synapse.cpp
1 /*
2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #include <assert.h>
23
24 // seems to be required for str.h
25 #include <glib.h>
26 #include <glib/gstdio.h>
27
28 #include "synapse.h"
29 #if defined (__linux__) || defined (__APPLE__)
30   #include <dirent.h>
31 #endif
32
33 /*
34 ===================================================
35 diagnostic stuff
36 ===================================================
37 */
38
39 extern "C"
40 {
41
42 static PFN_SYN_PRINTF_VA g_pPrintf = NULL;  
43   
44 void Set_Syn_Printf(PFN_SYN_PRINTF_VA pf)
45 {
46   g_pPrintf = pf;
47 }
48
49 #define BUFFER_SIZE 4096
50
51 void Syn_Printf (const char *text, ...)
52 {
53   char buf[BUFFER_SIZE];
54   va_list args;
55   
56   if (!text)
57     return;
58   
59   if (g_pPrintf)
60   {
61     va_start (args, text);
62     (*g_pPrintf)(text, args);
63     va_end (args);
64   }
65   else
66   {
67     va_start (args, text);
68     vsnprintf (buf, BUFFER_SIZE, text, args);
69     buf[BUFFER_SIZE-1] = 0;
70     printf(buf);
71     va_end (args);
72   }
73 }
74
75 }
76
77 /*
78 =======================================================================
79 server
80 =======================================================================
81 */
82
83 // this must be kept in sync with EAPIType
84 static const char* APITypeName[4] =
85 {
86   "SYN_UNKNOWN",
87   "SYN_PROVIDE",
88   "SYN_REQUIRE",
89   "SYN_REQUIRE_ANY"
90 };
91
92 CSynapseServer::CSynapseServer()
93 {
94   mpDoc = NULL;
95   m_api_name = NULL;
96   m_content = NULL;
97   mpFocusedNode = NULL;
98 }
99
100 CSynapseServer::~CSynapseServer()
101 {
102   if (m_api_name)
103     xmlFree(m_api_name);
104   if (m_content)
105     g_free(m_content);
106   Syn_Printf("TODO: free API managers\n");
107 }
108
109 void CSynapseServer::AddSearchPath(char* path)
110 {
111   char *pLocalPath = new char[strlen(path)+1];
112   strcpy(pLocalPath, path);
113   mSearchPaths.push_front(pLocalPath);
114 }
115
116 bool CSynapseServer::Initialize(const char* conf_file, PFN_SYN_PRINTF_VA pf)
117 {
118   // browse the paths to locate all potential modules
119   
120   Set_Syn_Printf(pf);
121   
122   if (conf_file)
123   {
124     // if a config file is specified and we fail to load it, we fail
125     Syn_Printf("loading synapse XML config file '%s'\n", conf_file);
126     mpDoc = xmlParseFile(conf_file);
127     if (!mpDoc)
128     {
129       Syn_Printf("'%s' invalid/not found\n", conf_file);
130       return false;
131     }    
132   }
133
134   for (list<char *>::iterator iPath=mSearchPaths.begin(); iPath!=mSearchPaths.end(); iPath++)
135   {
136     const char* path = *iPath;
137
138     Syn_Printf("Synapse Scanning modules path: %s\n", path);
139
140     GDir* dir = g_dir_open (path, 0, NULL);
141
142     if (dir != NULL)
143     {
144       while (1)
145       {
146         const gchar* name = g_dir_read_name(dir);
147         if(name == NULL)
148           break;
149
150         // too small to be isolated in win32/ and linux/ directories..
151 #if defined(_WIN32)
152         const char* ext_so = ".dll";
153 #elif defined (__linux__) || defined (__APPLE__)
154         const char* ext_so = ".so";
155 #endif
156         const char* ext = strrchr (name, '.');
157         if ((ext == NULL) || (stricmp (ext, ext_so) != 0))
158           continue;
159
160         Str newModule;
161         newModule.Format("%s%s", path, name);
162         Syn_Printf("Found '%s'\n", newModule.GetBuffer());      
163         EnumerateInterfaces(newModule);
164       }
165
166       g_dir_close(dir);
167     }
168   }
169   return true;
170 }
171
172 #if defined(_WIN32)  
173 #define FORMAT_BUFSIZE 2048
174 const char* CSynapseServer::FormatGetLastError()
175 {
176   static char buf[FORMAT_BUFSIZE];
177   FormatMessage(
178     FORMAT_MESSAGE_FROM_SYSTEM | 
179     FORMAT_MESSAGE_IGNORE_INSERTS,
180     NULL,
181     GetLastError(),
182     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
183     buf,
184     FORMAT_BUFSIZE,
185     NULL 
186   );
187   return buf;
188 }
189
190 void CSynapseServer::EnumerateInterfaces(Str &soname)
191 {
192   CSynapseClientSlot slot;
193   slot.mpDLL = LoadLibrary(soname.GetBuffer());
194   if (!slot.mpDLL)
195   {
196     Syn_Printf("LoadLibrary '%s' failed\n", soname.GetBuffer());
197     Syn_Printf("  GetLastError: %s", FormatGetLastError());
198     return;
199   }
200   slot.mpEnumerate = (PFN_SYNAPSE_ENUMERATEINTERFACES)GetProcAddress(slot.mpDLL, NAME_SYNAPSE_ENUMERATEINTERFACES);
201   if (!slot.mpEnumerate)
202   {
203     Syn_Printf("GetProcAddress('%s') failed\n", NAME_SYNAPSE_ENUMERATEINTERFACES);
204     Syn_Printf("  GetLastError: %s", FormatGetLastError());
205     return;
206   }
207   Syn_Printf("Enumerate interfaces on '%s'\n", soname.GetBuffer());
208   slot.mpClient = slot.mpEnumerate(SYNAPSE_VERSION, this);
209   if (!slot.mpClient)
210   {
211     Syn_Printf("Enumerate interfaces on '%s' returned NULL, unloading.\n", soname.GetBuffer());
212     if (!FreeLibrary(slot.mpDLL))
213     {
214       Syn_Printf(" FreeLibrary failed: GetLastError: '%s'\n", CSynapseServer::FormatGetLastError());
215     }
216     return;
217   }
218   slot.mFileName = soname;
219   mClients.push_front(slot);
220 }
221
222 void CSynapseClientSlot::ReleaseSO()
223 {
224   if (!mpDLL)
225   {
226     Syn_Printf("ERROR: no shared object handle for client '%s' in CSynapseClientSlot::ReleaseSO\n", mpClient->GetInfo());
227     return;
228   }
229   Syn_Printf("FreeLibrary '%s'\n", mpClient->GetInfo());
230   if (!FreeLibrary(mpDLL))
231   {
232     Syn_Printf(" FreeLibrary failed: GetLastError: '%s'\n", CSynapseServer::FormatGetLastError());
233   }
234   mpDLL = NULL;
235 }
236
237 #elif defined(__linux__) || defined (__APPLE__)
238 void CSynapseServer::EnumerateInterfaces(Str &soname)
239 {
240   CSynapseClientSlot slot;
241   slot.mpDLL = dlopen (soname.GetBuffer(), RTLD_NOW);
242   PFN_SYNAPSE_ENUMERATEINTERFACES *pEnumerate;
243   if (!slot.mpDLL)
244   {
245     char* error;
246     if ((error = (char *)dlerror()) == NULL)
247       error = "Unknown";
248     Syn_Printf("dlopen '%s' failed\n  dlerror: '%s'\n", soname.GetBuffer(), error);
249     return;
250   }
251   slot.mpEnumerate = (PFN_SYNAPSE_ENUMERATEINTERFACES)dlsym(slot.mpDLL, NAME_SYNAPSE_ENUMERATEINTERFACES);
252   if (!slot.mpEnumerate)
253   {
254     char* error;
255     if ((error = (char *)dlerror()) == NULL)
256       error = "Unknown";
257     Syn_Printf("dlsym '%s' failed on shared object '%s'\n  dlerror: '%s'\n", NAME_SYNAPSE_ENUMERATEINTERFACES, soname.GetBuffer(), error);
258     return;
259   }
260   Syn_Printf("Enumerate interfaces on '%s'\n", soname.GetBuffer());
261   slot.mpClient = slot.mpEnumerate(SYNAPSE_VERSION, this);
262   if (!slot.mpClient)
263   {
264     Syn_Printf("Enumerate interfaces on '%s' returned NULL, unloading.\n", soname.GetBuffer());
265     if (dlclose(slot.mpDLL))
266     {
267       char* error;
268       if ((error = (char *)dlerror()) == NULL)
269         error = "Unknown";
270       Syn_Printf("  dlclose failed: dlerror: '%s'\n", error);
271     }
272     return;
273   }
274   slot.mFileName = soname;
275   mClients.push_front(slot);
276 }
277
278 void CSynapseClientSlot::ReleaseSO()
279 {
280   if (!mpDLL)
281   {
282     Syn_Printf("ERROR: no shared object handle for client '%s' in CSynapseClientSlot::ReleaseSO\n", mpClient->GetInfo());
283     return;
284   }
285   Syn_Printf("dlclose '%s'\n", mpClient->GetInfo());
286   if (dlclose(mpDLL))
287   {
288     char* error;
289     if ((error = (char *)dlerror()) == NULL)
290       error = "Unknown";
291     Syn_Printf("  dlclose failed: dlerror: '%s'\n", error);
292   }
293   mpDLL = NULL;
294 }
295
296 #endif
297
298 void CSynapseServer::EnumerateBuiltinModule(CSynapseBuiltinClient *pClient)
299 {
300   CSynapseClientSlot slot;
301   pClient->EnumerateInterfaces(this);
302   slot.mpClient = pClient;
303   slot.mType = SYN_BUILTIN;
304   mClients.push_front(slot);
305 }
306
307 PFN_SYN_PRINTF_VA CSynapseServer::Get_Syn_Printf()
308 {
309   return g_pPrintf;
310 }
311
312 void CSynapseServer::TryPushStack(APIDescriptor_t *pAPI)
313 {
314   list<APIDescriptor_t*>::iterator iAPI;
315   for(iAPI=mStack.begin(); iAPI!=mStack.end(); iAPI++)
316   {
317     if ((*iAPI) == pAPI)
318     {
319       return;
320     }
321   }
322   mStack.push_front(pAPI);      
323   mbStackChanged = true;  
324 }
325
326 list<CSynapseClientSlot>::iterator CSynapseServer::ShutdownClient(list<CSynapseClientSlot>::iterator iSlot)
327 {
328   CSynapseClientSlot *pClientSlot = &(*iSlot);
329   if (pClientSlot->mpClient->IsActive())
330   {
331     // this should not happen except during core shutdown (i.e. editor is shutting down)
332     Syn_Printf("WARNING: ShutdownClient attempted on an active module '%s'\n", pClientSlot->mpClient->GetInfo());
333   }
334   // cleanup mStack
335   int i,api_count;
336   api_count = pClientSlot->mpClient->GetAPICount();
337   for(i=0; i<api_count; i++)
338   {
339     APIDescriptor_t *pAPI = pClientSlot->mpClient->GetAPIDescriptor(i);
340     // search this API in mStack
341     list< APIDescriptor_t *>::iterator iStack = mStack.begin();
342     while(iStack != mStack.end())
343     {
344       if (*iStack == pAPI)
345         break;
346       iStack++;
347     }
348     if (iStack != mStack.end())
349     {
350       if (pAPI->mType == SYN_REQUIRE)
351       {
352         if (pAPI->mbTableInitDone)
353         {
354           // even if non active, some SYN_REQUIRE may have been filled up
355           // look for the corresponding SYN_PROVIDE and decref
356           list< APIDescriptor_t *>::iterator iStackRequire = mStack.begin();
357           APIDescriptor_t *pMatchAPI;
358           while (iStackRequire != mStack.end())
359           {
360             pMatchAPI = *iStackRequire;
361             if ( pMatchAPI->mType == SYN_PROVIDE && MatchAPI( pMatchAPI, pAPI ) )
362               break;
363             iStackRequire++;
364           }
365           if (iStackRequire != mStack.end())
366           {
367             // we have found the corresponding SYN_PROVIDE
368             pMatchAPI->mRefCount--;
369           }
370           else
371           {
372             // this is not supposed to happen at all
373             Syn_Printf("ERROR: couldn't find the SYN_PROVIDE for an initialized SYN_REQUIRE API '%s' '%s' '%s'\n", pAPI->major_name, pAPI->minor_name, pClientSlot->mpClient->GetInfo());
374           }
375         }
376       }      
377       else if (pAPI->mType == SYN_PROVIDE)
378       {
379         // this should never happen on non active clients, it may happen during a core shutdown though
380         // if the mRefCount is != 0, that means there is at least a function table out there that will segfault things
381         Syn_Printf("WARNING: found a SYN_PROVIDE API '%s' '%s' with refcount %d in CSynapseServer::ShutdownClient for '%s'\n", pAPI->major_name, pAPI->minor_name, pAPI->mRefCount, pClientSlot->mpClient->GetInfo());
382       }
383       // mostly safe to remove it now
384       mStack.erase(iStack);
385     }
386   }
387   // we can actually release the module now
388   // NOTE: do we want to have a 'final shutdown' call to the client? (not as long as we don't have a use for it)
389   if (pClientSlot->mType == SYN_SO)
390   {
391     pClientSlot->ReleaseSO();
392   }  
393   return mClients.erase(iSlot);
394 }
395
396 void CSynapseServer::PushRequired(CSynapseClient *pClient)
397 {
398   /* walk through the standard APIs and push them in */
399   int i,max = pClient->GetAPICount();  
400   for(i=0; i<max; i++)
401   {
402     APIDescriptor_t* pAPI = pClient->GetAPIDescriptor(i);
403     if (pAPI->mType == SYN_REQUIRE && !pAPI->mbTableInitDone)
404     {
405       TryPushStack(pAPI);
406     }
407   }
408   
409   /* if this client has 'List' API Manager types, walk through them for addition too */
410   max = pClient->GetManagerListCount();
411   for(i=0; i<max; i++)
412   {
413     CSynapseAPIManager *pManager = pClient->GetManagerList(i);
414     assert(pManager->GetType() == API_LIST);
415     pManager->InitializeAPIList();
416     int j;
417     for(j=0; j<pManager->GetAPICount(); j++)
418     {
419       TryPushStack(pManager->GetAPI(j));
420     }
421   }
422   
423   /* if there are loose match managers, prompt them against the current list of SYN_PROVIDE interfaces
424    * and let them decide which ones they might want
425    */
426   
427   max = pClient->GetManagerMatchCount();
428
429   for(i=0; i<max; i++)
430   {
431     CSynapseAPIManager *pManager = pClient->GetManagerMatch(i);
432     // start matching all known SYN_PROVIDE APIs against this manager
433     list<CSynapseClientSlot>::iterator iClientSlot;
434     for(iClientSlot=mClients.begin(); iClientSlot!=mClients.end(); iClientSlot++)
435     {
436       CSynapseClient *pScanClient = (*iClientSlot).
437       mpClient;
438       int j,jmax = pScanClient->GetAPICount();
439       for(j=0; j<jmax; j++)
440       {
441         APIDescriptor_t *pAPI = pScanClient->GetAPIDescriptor(j);
442         if (pAPI->mType == SYN_PROVIDE)
443         {
444           if (pManager->MatchAPI(pAPI->major_name, pAPI->minor_name))
445           {
446             /*! we are going to want to load this one
447                * NOTE TTimo: what if this can not be resolved in the end?
448                * if this happens, then the whole startup will fail instead
449                * or we can use SYN_REQUIRE_ANY and drop it without consequences
450                */
451             APIDescriptor_t *pPushAPI = pManager->BuildRequireAPI(pAPI);
452             TryPushStack(pPushAPI);
453           }
454         }
455       }
456     }
457   }
458 }
459
460 bool CSynapseServer::MatchAPI(APIDescriptor_t *p1, APIDescriptor_t *p2)
461 {
462   return MatchAPI( p1->major_name, p1->minor_name, p2->major_name, p2->minor_name );
463 }
464
465 bool CSynapseServer::MatchAPI(const char* major1, const char* minor1, const char* major2, const char* minor2)
466 {
467   if ( strcmp( major1, major2 ) ) {
468     return false;
469   }
470   // either no minor at all for this API, or matching
471   if ( ( minor1 && minor2 ) && !strcmp( minor1, minor2 ) ) {
472     return true;
473   }
474   // or one of the minors says "*" (knowing that the majors match already)
475   if ( ( minor1 && !strcmp( minor1, "*" ) ) || ( minor2 && !strcmp( minor2, "*" ) ) ) {
476     return true;
477   }
478   return false;
479 }
480
481 bool CSynapseServer::ResolveAPI(APIDescriptor_t* pAPI)
482 {
483   //Syn_Printf("In ResolveAPI %s %p '%s' '%s'\n", APITypeName[pAPI->mType], pAPI, pAPI->major_name, pAPI->minor_name);  
484   // loop through active clients, search for a client providing what we are looking for
485   list<CSynapseClientSlot>::iterator iClient;
486   for(iClient=mClients.begin(); iClient!=mClients.end(); iClient++)
487   {
488     // walk through interfaces on this client for a match
489     CSynapseClient *pScanClient = (*iClient).mpClient;
490     int i,max = pScanClient->GetAPICount();
491     for(i=0; i<max; i++)
492     {
493       APIDescriptor_t *pScanClientAPI = pScanClient->GetAPIDescriptor(i);
494       if (pScanClientAPI->mType == SYN_PROVIDE)
495       {
496         if (MatchAPI(pAPI, pScanClientAPI))
497         {
498           // can this client provide APIs yet
499           // it is possible that all of it's APIs have been filled and it's not been activated yet
500           pScanClient->CheckSetActive();
501           if (pScanClient->IsActive())
502           {
503             // make sure this interface has correct size (this is our version check)
504             if (pAPI->mSize != pScanClientAPI->mSize)
505             {
506               Syn_Printf("ERROR: version mismatch for API '%s' '%s' found in '%s' (size %d != %d)\n", pAPI->major_name, pAPI->minor_name, pScanClient->GetInfo(), pAPI->mSize, pScanClientAPI->mSize);
507               Syn_Printf("  the module and the server are incompatible\n");
508               // keep going to other APIs
509               continue;
510             }
511             // this is an active client, we can request
512             #ifdef SYNAPSE_VERBOSE
513               Syn_Printf("RequestAPI '%s' '%s' from '%s' for API %p\n", pAPI->major_name, pAPI->minor_name, pScanClient->GetInfo(), pAPI);
514             #endif
515             if (!pScanClient->RequestAPI(pAPI))
516             {
517               // this should never happen, means we think this module provides the API, but it answers that it doesn't
518               Syn_Printf("ERROR: RequestAPI failed\n");
519               return false;
520             }
521             pScanClientAPI->mRefCount++;
522             pAPI->mbTableInitDone = true;
523             return true; // job done
524           }
525           else
526           {
527             // this client is not active yet, some of it's required interfaces are not filled in
528             PushRequired(pScanClient);
529             // we will exit the scan through the APIDescriptor of this client and look at other clients
530             break;
531           }
532         }
533       }
534     }  
535   }
536   return false;
537 }
538
539 bool CSynapseServer::DoResolve(CSynapseClient *pClient)
540 {
541   list<CSynapseClientSlot>::iterator iSlot;
542   for(iSlot=mClients.begin(); iSlot != mClients.end(); iSlot++)
543   {
544     if ((*iSlot).mpClient == pClient)
545       break;
546   }
547   if (iSlot == mClients.end())
548   {
549     Syn_Printf("CSynapserServer::Resolve adding new client slot '%s'\n", pClient->GetInfo());
550     CSynapseClientSlot slot;
551     slot.mpClient = pClient;
552     slot.mFileName = "local client";
553     // make it active so we can request the interfaces already
554     pClient->ForceSetActive();
555     mClients.push_front(slot);
556   }
557   else
558   {
559     // make it active so we can request the interfaces already
560     (*iSlot).mpClient->ForceSetActive();
561   }
562
563   // push the interfaces that need to be resolved for this client  
564   // NOTE: this doesn't take care of the SYN_REQUIRE_ANY interfaces
565   PushRequired(pClient);
566   // start resolving now
567   // working till the stack is emptied or till we reach a dead end situation
568   // we do a depth first traversal, we will grow the interface stack to be resolved till we start finding solutions
569   list<APIDescriptor_t*>::iterator iCurrent;
570   mbStackChanged = true; // init to true so we try the first elem
571   while (!mStack.empty())
572   {
573     //DumpStack();
574     if (!mbStackChanged)
575     {
576       // the stack didn't change last loop 
577       iCurrent++;
578       if (iCurrent==mStack.end())
579       {
580         Syn_Printf("ERROR: CSynapseServer::Resolve, failed to resolve\n");
581         DumpStack();
582         return false;
583       }
584       if (ResolveAPI(*iCurrent))
585       {
586         iCurrent = mStack.erase(iCurrent);
587         mbStackChanged = true;
588       }
589     }
590     else
591     {
592       // the stack changed at last loop
593       mbStackChanged = false;
594       iCurrent = mStack.begin();
595       if (ResolveAPI(*iCurrent))
596       {
597         iCurrent = mStack.erase(iCurrent);
598         mbStackChanged = true;
599       }
600     }
601   }
602   return true;
603 }
604
605 bool CSynapseServer::Resolve(CSynapseClient *pClient)
606 {
607   bool ret = DoResolve(pClient);
608   list<CSynapseClientSlot>::iterator iClient;  
609   iClient = mClients.begin();
610   while(iClient != mClients.end())
611   {
612     CSynapseClient *pClient = (*iClient).mpClient;
613     if (!pClient->IsActive())
614     {
615       Syn_Printf("Unloading an unused module: '%s'\n", pClient->GetInfo());
616       iClient = ShutdownClient(iClient);
617     }
618     else
619       iClient++;
620   }
621   return ret;
622 }
623
624 void CSynapseServer::Shutdown()
625 {
626   Syn_Printf("Synapse server core is shutting down\n");
627   // do a first pass to shutdown the clients nicely (i.e. decref, release memory and drop everything)
628   // we seperate the client shutdown calls from the dlclose cause that part is a clean decref / free situation whereas dlclose will break links without advice
629   list<CSynapseClientSlot>::iterator iClient;  
630   iClient = mClients.begin();
631   for(iClient = mClients.begin(); iClient != mClients.end(); iClient++)
632   {
633     (*iClient).mpClient->Shutdown();
634   }  
635   // now release them from the server's point of view
636   iClient = mClients.begin();
637   while(iClient != mClients.end())
638   {
639     iClient = ShutdownClient(iClient);
640   }  
641 }
642
643 void CSynapseServer::DumpStack()
644 {
645   list<APIDescriptor_t*>::iterator iCurrent;
646   for(iCurrent=mStack.begin(); iCurrent != mStack.end(); iCurrent++)
647   {
648     APIDescriptor_t*pAPI = *iCurrent;
649     Syn_Printf("interface %s %p '%s' '%s'\n", APITypeName[pAPI->mType], pAPI, pAPI->major_name, pAPI->minor_name);
650   }
651 }
652
653 void CSynapseServer::DumpActiveClients()
654 {
655   list<CSynapseClientSlot>::iterator iClient;  
656   for(iClient=mClients.begin(); iClient!=mClients.end(); iClient++)
657   {
658     CSynapseClient *pClient = (*iClient).mpClient;
659     Syn_Printf("%s", pClient->GetInfo());
660     if (pClient->IsActive())
661       Syn_Printf("\n");
662     else
663       Syn_Printf(" (not active)\n");
664   }
665 }
666
667 bool CSynapseServer::SelectClientConfig(const char *client_name)
668 {
669   if (!mpDoc)
670     return false;
671   xmlNodePtr pNode = xmlDocGetRootElement(mpDoc);
672   if (!pNode)
673     return false;
674   // look for the client
675   pNode=pNode->children;
676   while(pNode)
677   {
678     if (pNode->type == XML_ELEMENT_NODE)
679     {
680       xmlChar *prop = xmlGetProp(pNode, (const xmlChar *)"name");
681       if (!strcmp((const char *)prop, client_name))
682       {
683         xmlFree(prop);
684         break;
685       }
686       xmlFree(prop);
687     }
688     pNode = pNode->next;
689   }
690   if (!pNode)
691     return false; // config you asked for isn't there
692   // focus
693   mpFocusedNode = pNode->children;
694   mpCurrentClientConfig = pNode;
695   return true;
696 }
697
698 bool CSynapseServer::GetNextConfig(char **api_name, char **minor)
699 {
700   while(mpFocusedNode && mpFocusedNode->name)
701   {
702     if (mpFocusedNode->type == XML_ELEMENT_NODE && !strcmp((const char *)mpFocusedNode->name, "api"))
703     {
704       if (m_api_name)
705         xmlFree(m_api_name);
706       m_api_name = xmlGetProp(mpFocusedNode, (const xmlChar *)"name");
707       *api_name = (char *)m_api_name;
708       if (m_content)
709         g_free(m_content);
710       m_content = g_strdup((const gchar *)mpFocusedNode->children->content);
711       g_strstrip(m_content);
712       *minor = m_content;
713       mpFocusedNode = mpFocusedNode->next;
714       return true;
715     }
716     mpFocusedNode = mpFocusedNode->next;    
717   }
718   return false;
719 }
720
721 bool CSynapseServer::GetConfigForAPI( const char *api, char **minor ) {
722   xmlNodePtr pNode = mpCurrentClientConfig->children;
723   while ( pNode && pNode->name ) {
724     if ( pNode->type == XML_ELEMENT_NODE && !strcmp( (const char *)pNode->name, "api" ) ) {
725       if ( m_api_name ) {
726         xmlFree( m_api_name );
727       }
728       m_api_name = xmlGetProp( pNode, (const xmlChar *)"name" );
729       if ( !strcmp( (const char *)m_api_name, api ) ) {
730         if ( m_content ) {
731           g_free( m_content );
732         }
733         m_content = g_strdup( (const gchar *)pNode->children->content );
734         g_strstrip( m_content );
735         *minor = m_content;
736         return true;
737       }
738     }
739     pNode = pNode->next;
740   }
741   return false;
742 }
743
744 const char *CSynapseServer::GetModuleFilename(CSynapseClient *pClient)
745 {
746   list<CSynapseClientSlot>::iterator iSlot;
747   for(iSlot=mClients.begin(); iSlot != mClients.end(); iSlot++)
748   {
749     if ((*iSlot).mpClient == pClient)
750     {
751       if ((*iSlot).mType == SYN_BUILTIN)
752       {
753         return "";      // FIXME
754       }
755       else
756       {
757         return (*iSlot).mFileName;
758       }
759     }
760   }
761   return NULL;
762 }
763
764 /*
765 =======================================================================
766 client
767 =======================================================================
768 */
769
770 CSynapseClient::CSynapseClient()
771 {
772 }
773
774 void CSynapseClient::Shutdown()
775 {
776   vector<APIDescriptor_t *>::iterator iAPI;
777   for(iAPI=mAPIDescriptors.begin(); iAPI!=mAPIDescriptors.end(); iAPI++)
778   {
779     APIDescriptor_t *pAPI = *iAPI;
780     if (pAPI->mRefCount != 0)
781       Syn_Printf("WARNING: ~CSynapseClient '%s' has non-zero ref count for interface '%s' '%s'\n", GetInfo(), pAPI->major_name, pAPI->minor_name);
782     else
783       delete pAPI;
784     *iAPI=NULL;
785   }
786   mAPIDescriptors.clear();
787   vector<CSynapseAPIManager *>::iterator iManager;
788   for(iManager=mManagersList.begin(); iManager!=mManagersList.end(); iManager++)
789   {
790     CSynapseAPIManager *pManager = *iManager;
791     pManager->DecRef();
792     *iManager = NULL;
793   }
794   mManagersList.clear();
795   for(iManager=mManagersMatch.begin(); iManager!=mManagersMatch.end(); iManager++)
796   {
797     CSynapseAPIManager *pManager = *iManager;
798     pManager->DecRef();
799     *iManager = NULL;
800   }
801   mManagersMatch.clear();
802 }
803
804 CSynapseClient::~CSynapseClient()
805 {
806   // this should not be doing anything when called from here if everything went right
807   // otherwise it's likely to crash .. at least that's the sign we missed something
808   Shutdown();
809 }
810
811 int CSynapseClient::GetAPICount()
812 {
813   return mAPIDescriptors.size();
814 }
815
816 APIDescriptor_t* CSynapseClient::GetAPIDescriptor(int i)
817 {
818   return mAPIDescriptors[i];
819 }
820
821 int CSynapseClient::GetManagerMatchCount()
822 {
823   return mManagersMatch.size();
824 }
825
826 CSynapseAPIManager* CSynapseClient::GetManagerMatch(int i)
827 {
828   return mManagersMatch[i];
829 }
830
831 int CSynapseClient::GetManagerListCount()
832 {
833   return mManagersList.size();
834 }
835
836 CSynapseAPIManager* CSynapseClient::GetManagerList(int i)
837 {
838   return mManagersList[i];
839 }
840
841 bool CSynapseClient::AddAPI(const char *major, const char *minor, int size, EAPIType type, void *pTable)
842 {
843   // do some safe checks before actual addition
844   if (type == SYN_REQUIRE && !pTable)
845   {
846     Syn_Printf("ERROR: interface '%s' '%s' from '%s' is SYN_REQUIRE and doesn't provide a function table pointer\n", major, minor, GetInfo());
847     return false;
848   }
849   if (pTable)
850   {
851     int *pi = (int *)pTable;
852     if (pi == 0)
853     {
854       Syn_Printf("ERROR: forgot to init function table size for interface '%s' '%s' from '%s'?\n", major, minor, GetInfo());
855       return false;
856     }
857   }
858   APIDescriptor_t *pAPI = new APIDescriptor_t;
859   memset(pAPI, 0, sizeof(APIDescriptor_t));
860   strncpy(pAPI->major_name, major, MAX_APINAME);
861   if (minor)
862     strncpy(pAPI->minor_name, minor, MAX_APINAME);
863   pAPI->mType = type;
864   pAPI->mpTable = pTable;
865   // store the interface size
866   if (type == SYN_PROVIDE)
867   {
868     if (size == 0)
869     {
870       Syn_Printf("ERROR: size of the interface required for a SYN_PROVIDE ('%s' '%s' from '%s')\n", major, minor, GetInfo());
871       delete pAPI;
872       return false;
873     }
874     pAPI->mSize = size;
875   }
876   else if (type == SYN_REQUIRE)
877   {    
878     if (size != 0)
879     {
880       // if a non-zero value is given in function call, use this instead of the val in table
881       *((int *)pAPI->mpTable) = size;
882       pAPI->mSize = size;
883     }
884     else
885     {
886       pAPI->mSize = *((int *)pAPI->mpTable);
887       if (pAPI->mSize == 0)
888       {
889         Syn_Printf("ERROR: didn't get an interface size ('%s' '%s' from '%s')\n", major, minor, GetInfo());
890         delete pAPI;
891         return false;
892       }
893     }
894   }
895   else
896   {
897     Syn_Printf("ERROR: AddAPI type '%d' not supported\n", type);
898     return false;
899   }
900   mAPIDescriptors.push_back(pAPI);  
901   #ifdef SYNAPSE_VERBOSE
902     Syn_Printf("AddAPI: %s %p '%s' '%s' from '%s', size %d\n", APITypeName[pAPI->mType], pAPI, major, minor, GetInfo(), pAPI->mSize);
903   #endif
904   return true;
905 }
906
907 #include "version.h"
908
909 const char* CSynapseClient::GetInfo()
910 {
911   return "CSynapseClient built " __DATE__ " " RADIANT_VERSION;
912 }
913
914 bool CSynapseClient::CheckSetActive()
915 {
916   if (mbActive)
917     return true;
918   int i,max=GetAPICount();
919   for(i=0; i<max; i++)
920   {
921     APIDescriptor_t *pAPI = GetAPIDescriptor(i);
922     if (pAPI->mType == SYN_REQUIRE && !pAPI->mbTableInitDone)
923       return false;
924   }
925   // if we have managers with fixed list, those need to be completely filled in too
926   vector<CSynapseAPIManager *>::iterator iManager;
927   for(iManager=mManagersList.begin(); iManager!=mManagersList.end(); iManager++)
928   {
929     if (!(*iManager)->CheckSetActive())
930       return false; // one of the managers doesn't have all it needs yet
931   }
932   // call OnActivate to let the client perform last minute checks
933   // NOTE: this should be fatal instead of letting the engine try other combinations
934   if (!OnActivate()) {
935     return false;
936   }
937   // yes, all required interfaces have been initialized
938   Syn_Printf("'%s' activated\n", GetInfo());
939   mbActive = true;
940   return true;
941 }
942
943 bool CSynapseClient::ConfigXML( CSynapseServer *pServer, const char *client_name, const XMLConfigEntry_t entries[] ) {
944   
945   if ( !client_name ) {
946     client_name = GetName();
947   }
948   
949   Syn_Printf("Dynamic APIs for client '%s'\n", GetInfo());
950   if ( !pServer->SelectClientConfig( client_name ) )
951   {
952     Syn_Printf( "Failed to select synapse client config '%s'\n", client_name );
953     return false;
954   }
955   
956   int i = 0;
957   while ( entries[i].type != SYN_UNKNOWN ) { // don't test pTable, for a SYN_PROVIDE it will be empty
958     char *minor;
959     if ( !pServer->GetConfigForAPI( entries[i].api, &minor ) ) {
960       Syn_Printf( "GetConfigForAPI '%s' failed - invalid XML config file?\n", entries[i].api );
961       return false;
962     }
963     AddAPI( entries[i].api, minor, entries[i].size, entries[i].type, entries[i].pTable );
964     i++;
965   }
966   Syn_Printf( "%d dynamic interfaces parsed for '%s'\n", i, client_name );
967   return true;
968 }
969
970 void CSynapseClient::AddManager(CSynapseAPIManager *pManager)
971 {
972   pManager->IncRef();
973   if (pManager->GetType() == API_LIST)
974     mManagersList.push_back(pManager);
975   else
976     mManagersMatch.push_back(pManager);
977 }
978
979 CSynapseAPIManager::~CSynapseAPIManager()
980 {
981   vector<APIDescriptor_t *>::iterator iAPI;
982   for(iAPI=mAPIs.begin(); iAPI!=mAPIs.end(); iAPI++)
983   {
984     APIDescriptor_t *pAPI = *iAPI;
985     if (pAPI->mRefCount != 0)
986     {
987       Syn_Printf("WARNING: ~CSynapseAPIManager has non-zero ref count for interface '%s' '%s'\n", pAPI->major_name, pAPI->minor_name);
988     }
989     delete pAPI;
990     *iAPI = NULL;
991   }
992 }
993
994 APIDescriptor_t* CSynapseAPIManager::PrepareRequireAPI(APIDescriptor_t *pAPI)
995 {
996 #ifdef _DEBUG
997   if (pAPI->mType != SYN_PROVIDE)
998   {
999     Syn_Printf("ERROR: unexpected pAPI->mType != SYN_PROVIDE in CSynapseAPIManager::PrepareRequireAPI\n");
1000     return NULL;
1001   }
1002 #endif
1003   APIDescriptor_t *pRequireAPI = new APIDescriptor_t;
1004   memcpy(pRequireAPI, pAPI, sizeof(APIDescriptor_t));
1005   pRequireAPI->mType = SYN_REQUIRE_ANY;
1006   pRequireAPI->mpTable = NULL;
1007   pRequireAPI->mbTableInitDone = false;
1008   pRequireAPI->mSize = 0; // this will have to be set correctly by the child for version checking
1009   pRequireAPI->mRefCount = 0;
1010   return pRequireAPI;
1011 }
1012
1013 void CSynapseAPIManager::SetMatchAPI(const char *major, const char *minor)
1014 {
1015   if (strlen(minor)>MAX_PATTERN_STRING)
1016   {
1017     Syn_Printf("ERROR: MAX_TOKEN_STRING exceeded in CSynapseAPIManager::SetMatchAPI: '%s'\n", minor);
1018     return;
1019   }
1020   strcpy(major_pattern, major);
1021   strcpy(minor_pattern, minor);
1022   if (strcmp(minor, "*"))
1023   {
1024     mType = API_LIST;
1025   }
1026 }
1027
1028 bool CSynapseAPIManager::MatchAPI(const char *major, const char *minor)
1029 {
1030   assert(mType == API_MATCH);
1031   
1032   /*!
1033   if this interface has been allocated already, avoid requesting it again..
1034   */
1035   vector<APIDescriptor_t *>::iterator iAPI;
1036   for(iAPI=mAPIs.begin(); iAPI!=mAPIs.end(); iAPI++)
1037   {
1038     if (CSynapseServer::MatchAPI((*iAPI)->major_name, (*iAPI)->minor_name, major, minor))
1039       return false;
1040   }
1041   
1042   if (!strcmp(major, major_pattern))
1043     return true;
1044   return false;
1045 }
1046
1047 bool CSynapseAPIManager::CheckSetActive()
1048 {
1049   if (mType == API_MATCH)
1050     return false;
1051   // mType == API_LIST
1052   int i,max = GetAPICount();
1053   for(i=0; i<max; i++)
1054   {
1055     if (!GetAPI(i)->mbTableInitDone)
1056       return false;
1057   }
1058   return true;
1059 }
1060
1061 void CSynapseAPIManager::InitializeAPIList()
1062 {
1063   char minor_tok[MAX_PATTERN_STRING];
1064   char *token;
1065   
1066   if (mAPIs.size())
1067   {
1068     Syn_Printf("WARNING: CSynapseAPIManager::InitializeAPIList on an already initialized APIManager\n");
1069     return;
1070   }
1071   
1072   strncpy(minor_tok, minor_pattern, MAX_PATTERN_STRING);
1073   token = strtok(minor_tok, " ");
1074   while (token)
1075   {
1076     /* ask the child to build from scratch */
1077     APIDescriptor_t *pAPI = new APIDescriptor_t;
1078     memset(pAPI, 0, sizeof(APIDescriptor_t));
1079     strncpy(pAPI->major_name, major_pattern, MAX_APINAME);
1080     strncpy(pAPI->minor_name, token, MAX_APINAME);
1081     pAPI->mType = SYN_REQUIRE_ANY;
1082     FillAPITable(pAPI);
1083     mAPIs.push_back(pAPI);
1084     token = strtok(NULL, " ");
1085   }
1086 }
1087   
1088 int CSynapseAPIManager::GetAPICount()
1089 {
1090   return mAPIs.size();
1091 }
1092
1093 APIDescriptor_t* CSynapseAPIManager::GetAPI(int i)
1094 {
1095   return mAPIs[i];
1096 }
1097
1098 // http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=879
1099 void fini_stub() {
1100   printf( "fini_stub\n" );
1101 }