unix_dll_common.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:6k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "dllacces.h"
  36. #include <stdio.h>
  37. #include <string.h>
  38. #include <ctype.h>
  39. #include "hlxclib/sys/stat.h"
  40. #include "hxassert.h"
  41. #include "hxstrutl.h"
  42. #include "platform/unix/unix_dll_common.h"
  43. void HandleHXStopOnLoad(const char* libName)
  44. {
  45.     const char *dlls;
  46.     if (dlls = getenv ("HX_STOPONLOAD"))
  47.     {
  48. if (strstr(dlls, libName))
  49. {
  50.     HXDebugBreak();
  51. }
  52. else if (!strcmp("all", dlls))
  53. {
  54.     HXDebugBreak();
  55. }
  56.     }
  57. }
  58. char* UnixFindDLLVersion(const char* libName)
  59. {
  60.     char* pRet = 0;
  61.     int rc = 0;
  62.     char tmpPaths[MAXPATHLEN+1]; /* Flawfinder: ignore */
  63.     tmpPaths[0] = '';
  64.     // get list of semi-separated directories to search for library
  65.     char* libSearchPaths = getenv("LD_LIBRARY_PATH");
  66.     if(libSearchPaths)
  67.     {
  68. SafeStrCpy(tmpPaths, libSearchPaths, MAXPATHLEN+1);
  69. SafeStrCpy(tmpPaths, ";", MAXPATHLEN+1);
  70.     }
  71.     SafeStrCat(tmpPaths, "/usr/lib;/lib", MAXPATHLEN+1);
  72.     char* dirName = strtok(tmpPaths, ";");
  73.     while(dirName)
  74.     {
  75.         struct stat buf;
  76.         char pathName[MAXPATHLEN+1];  // current path /* Flawfinder: ignore */
  77.         char realPath[MAXPATHLEN+1];  // resolved path /* Flawfinder: ignore */
  78.         // lstat dirName/libName to get final inode
  79.         SafeStrCpy(pathName, dirName, MAXPATHLEN+1);
  80.         SafeStrCat(pathName, "/", MAXPATHLEN+1);
  81.         SafeStrCat(pathName, libName, MAXPATHLEN+1);
  82.         while(lstat(pathName, &buf) == 0)
  83.         {
  84.             if(S_ISLNK(buf.st_mode))    // need to get symlink
  85.             {
  86.                 char path[MAXPATHLEN+1]; /* Flawfinder: ignore */
  87.                 int linklen = readlink(pathName, path, sizeof(path)-1);
  88.                 if(linklen < 0) // pathName is not a link
  89.                 {
  90.                     if(path[0] == '.')  // relative path
  91.                     {
  92.                         SafeStrCpy(realPath, dirName, MAXPATHLEN+1);
  93.                         SafeStrCat(realPath, "/", MAXPATHLEN+1);
  94.                         SafeStrCat(realPath, path, MAXPATHLEN+1);
  95.                     }
  96.                     else
  97.                         SafeStrCpy(realPath, path, MAXPATHLEN+1);
  98.                     break;
  99.                 }
  100.                 // next dir
  101.                 path[linklen] = '';
  102.                 SafeStrCpy(pathName, dirName, MAXPATHLEN+1);
  103.                 SafeStrCat(pathName, "/", MAXPATHLEN+1);
  104.                 SafeStrCat(pathName, path, MAXPATHLEN+1);
  105.             }
  106.             else // this is the actual filename
  107.             {
  108. char path[MAXPATHLEN+1]; /* Flawfinder: ignore */
  109.                 SafeStrCpy(realPath, pathName, MAXPATHLEN+1);
  110.                 if(realpath(realPath, path))
  111. {
  112.     // now, finally, get version from actual file name
  113.     char version[20]; /* Flawfinder: ignore */
  114.     char tmp[20]; /* Flawfinder: ignore */
  115.     // walk backwards through the string until a letter is
  116.     // found ('o', for instance)
  117.     char* tPtr = tmp;
  118.     char* vPtr = &path[strlen(path)-1];
  119.     while(vPtr >= path && tPtr < version + 20 && !isalpha(*vPtr)) // XXX -- this is bogus
  120. *tPtr++ = *vPtr--;
  121.     *tPtr = '';
  122.     int len = strlen(tmp);
  123.     if(len > 0)
  124.     {
  125. // copy back to version, skipping over the initial '.'
  126. vPtr = &version[strlen(tmp)-1];
  127. *vPtr = '';
  128. vPtr--;
  129. tPtr = tmp;
  130. for(int i=0;i<len;i++)
  131.     *vPtr-- = *tPtr++;
  132. UINT32 bufSize = strlen(version) + 1;
  133. pRet = new char[bufSize];
  134. SafeStrCpy(pRet, version, bufSize);
  135.     }
  136.     else
  137.     {
  138. pRet = new char[1];
  139. HX_ASSERT(pRet);
  140. if (pRet)
  141.     *pRet = '';
  142.     }
  143.                     rc = 1;
  144. }
  145.                 break;
  146.             }
  147.         }
  148.         if(rc)
  149.             break;
  150.         dirName = strtok(NULL, ";");
  151.     }
  152.     return pRet;
  153. }
  154. void
  155. UnixCreateName(const char* short_name, const char* long_name, 
  156.       char* out_buf, UINT32& out_buf_len, 
  157.       UINT32 nMajor, UINT32 nMinor)
  158. {
  159.     UINT32  long_name_len;
  160.     out_buf[0] = 0;
  161.     long_name_len = strlen(long_name);
  162.     if (long_name_len + DLLAccess::EXTRA_BUF_LEN > out_buf_len)
  163.     {
  164. HX_ASSERT(0);
  165. out_buf_len = 0;
  166. return;
  167.     }
  168.     out_buf_len = sprintf(out_buf, "%s.so", long_name); /* Flawfinder: ignore */
  169. }