서비스 프로그램을 작성하다 보면, 디버깅을 할 때 현재 어플리케이션으로
구동중인지 서비스로 구동중인지를 내부적으로 구분할 수 있어야한다.
(여러가지 방법이 있겠지만, 아는게 없어서 ㅜㅜ)

이를 쉽게 해결하는 방법은 다음과 같다.

메인 쯔음해서 GetConsoleWindow() 함수를 호출한 결과를 가지고 여부를
자동으로 구분할 수 있다.

응용 프로그램 모드로 구동하게 되면 위 함수가 HWND 타입의 핸들을 리턴하게 된다.
하지만 시스템 서비스 모드로 구동중이라면 NULL을 리턴한다.

즉, 프로그램 main에서 저 핸들값을 이용하여 StartServiceCtrlDispatcher 를 호출할 것인지
디버그용 메인을 호출할 것인지를 결정할 수 있는 것이다.

곁들여서 GetUserName() 를 이용하여 현재 어떤 계정으로 구동하는지도
첨부하면 금상첨화겠죠?

How To Convert a UNIX time_t to a Win32 FILETIME or SYSTEMTIME

   #include <winbase.h>
   #include <winnt.h>
   #include <time.h>

   void UnixTimeToFileTime(time_t t, LPFILETIME pft)
   {
     // Note that LONGLONG is a 64-bit value
     LONGLONG ll;

     ll = Int32x32To64(t, 10000000) + 116444736000000000;
     pft->dwLowDateTime = (DWORD)ll;
     pft->dwHighDateTime = ll >> 32;
   }
				

   void UnixTimeToSystemTime(time_t t, LPSYSTEMTIME pst)
   {
     FILETIME ft;

     UnixTimeToFileTime(t, &ft);
     FileTimeToSystemTime(&ft, pst);
   }
				

Back to the top

권한에 관한 부분은 상당히 방대한 양이라.. 그냥 필요해서 쓰는것만 추려봤습니다.
MSDN에 잘 나와았지만 대부분 WCHAR 타입의 인자를 넘겨야해서 그냥 껍데기를
씌운 형태입니다. ^^;

1. 유저 영역
   -> 유저 생성, 유저 삭제, 유저 목록, 암호 변경, 유저가 속한 그룹 목록, 유저 정보등..

2. 그룹 영역
  -> 그룹 생성, 그룹 삭제, 그룹 목록, 그룹에 유저 추가, 그룹에서 유저 삭제등..

3. 권한 영역
  -> 유저의 SID 얻어오기, SID를 문자열로 만들기, 현재 유저의 권한 얻어오기
      권한의 활성화/비활성화, 프로세스에 속한 권한 목록 얻어오기, 권한 상승
      프로세스 소유자 얻어오기 등등...

// Policy.h: interface for the CPolicy class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_POLICY_H__8DE86AF1_C525_4546_A661_0FC4D12902EF__INCLUDED_)
#define AFX_POLICY_H__8DE86AF1_C525_4546_A661_0FC4D12902EF__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define RTN_OK 0
#define RTN_USAGE 1
#define RTN_ERROR 13

#include <ntsecapi.h>
#include <vector>
#include <comutil.h>
#include <lm.h>
#include <sddl.h>
#include <Ntsecapi.h>


namespace CLM // Control Local Machine
{
    LPCTSTR GetLogonUser();
    LPCTSTR GetHostName();
    LPCTSTR GetDomainName();

    LPWCH  MBtoWC(LPCTSTR src, PWCHAR dst, int dstlen);
    LPTSTR WCtoMB(LPCWCH src, LPTSTR dst, int dstlen);

    void InitLsaString(PLSA_UNICODE_STRING LsaString, LPWSTR String);

    NTSTATUS OpenPolicy(
        LPCTSTR ServerName,                // machine to open policy
        DWORD DesiredAccess,            // desired access to policy
        PLSA_HANDLE PolicyHandle);        // resultant policy handle, must be LsaClose(PolicyHandle)

    NTSTATUS OpenPolicy(
        PLSA_HANDLE PolicyHandle);        // resultant policy handle, must be LsaClose(PolicyHandle)

    BOOL GetUserSid(
        LPCTSTR servername,                // where to lookup account
        LPCTSTR username,                // account of interest
        PSID *Sid);                        // resultant buffer containing SID, must be HeapFree(GetProcessHeap(), 0, pSid);

    BOOL GetCurrentUserSid(
        PSID *pSid);                    // resultant buffer containing SID, must be HeapFree(GetProcessHeap(), 0, pSid);

    BOOL GetSIDToString(PSID sid, LPTSTR& strstring);

    namespace USER
    {
        /*  Declared in Lmaccess.h; include Lm.h. Use Netapi32.lib.

            NetUserAdd                Adds a user account and assigns a password and privilege level. 
            NetUserChangePassword    Changes a user's password for a specified network server or domain. 
            NetUserDel                Deletes a user account from the server. 
            NetUserEnum                Lists all user accounts on a server. 
            NetUserGetGroups        Returns a list of global group names to which a user belongs. 
            NetUserGetInfo            Returns information about a particular user account on a server. 
            NetUserGetLocalGroups    Returns a list of local group names to which a user belongs. 
            NetUserSetGroups        Sets global group memberships for a specified user account. 
            NetUserSetInfo            Sets the password and other elements of a user account. 
        */

        NET_API_STATUS NetUserAdd(
            LPCTSTR servername,                // NULL is localcomputer
            LPCTSTR username,                // Not NULL
            LPCTSTR password,                // allow NULL
            LPCTSTR comment,                // allow NULL
            DWORD privilege,                // USER_PRIV_GUEST, USER_PRIV_USER, USER_PRIV_ADMIN
            DWORD flags);                    // 권한에 대한 제한. UF_SCRIPT | UF_DONT_EXPIRE_PASSWD 기타 등등..

        NET_API_STATUS NetUserChangePassword(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR username,                // NULL is current logon user
            LPCTSTR oldpassword,            // current password, Not NULL
            LPCTSTR newpassword);            // new password, Not NULL
    
        NET_API_STATUS NetUserDel(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR username);                // Not NULL
    
        NET_API_STATUS NetUserEnum(
            LPCTSTR domainname,                // NULL is localcomputer
            LPDWORD dwCount,                // user count
            LPUSER_INFO_20& userinfos);        // user info array, must be free -> NetApiBufferFree(userinfos);
    
        NET_API_STATUS NetUserGetGroups(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR username,                // NULL is current user
            std::vector<_bstr_t>& parray);    // global group name array

        NET_API_STATUS NetUserGetInfo(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR username,                // NULL is current user
            LPUSER_INFO_20& userinfos);        // user info array, must be free -> NetApiBufferFree(userinfos);
    
        NET_API_STATUS NetUserGetLocalGroups(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR username,                // NULL is current user
            std::vector<_bstr_t>& parray);    // local group name array
    
        NET_API_STATUS NetUserSetGroups(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR username,                // NULL is current user
            LPCTSTR groupname);                // Not NULL, global groupname
    }


    namespace GROUP
    {
        /*  Declared in Lmaccess.h; include Lm.h. Use Netapi32.lib.

            NetLocalGroupAdd        Creates a local group. 
            NetLocalGroupAddMembers Adds one or more users or global groups to an existing local group. 
            NetLocalGroupDel        Deletes a local group, removing all existing members from the group. 
            NetLocalGroupDelMembers Removes one or more members from an existing local group. 
            NetLocalGroupEnum        Returns information about each local group account on a server. 
            NetLocalGroupGetInfo    Returns information about a particular local group account on a server. 
            NetLocalGroupGetMembers Lists all members of a specified local group. 
            NetLocalGroupSetInfo    Sets general information about a local group. 
            NetLocalGroupSetMembers Assigns members to a local group. 
        */
    
        NET_API_STATUS NetLocalGroupAdd(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR groupname,                // Not NULL, groupname
            LPCTSTR comment);                // Allow NULL

        NET_API_STATUS NetLocalGroupAddMembers(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR groupname,                // Not NULL, groupname
            LPCTSTR username);                // Not NULL, username

        NET_API_STATUS NetLocalGroupDel(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR groupname);                // Not NULL, groupname
    
        NET_API_STATUS NetLocalGroupDelMembers(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR groupname,                // Not NULL, groupname
            LPCTSTR username);                // Not NULL, username

        NET_API_STATUS NetLocalGroupEnum(
            LPCTSTR domainname,                // NULL is localcomputer
            LPDWORD dwCount,                // group count
            PLOCALGROUP_INFO_1& groupinfo);    // group info array, must be free -> NetApiBufferFree(groupinfo);

        NET_API_STATUS NetLocalGroupGetInfo(
            LPCTSTR domainname,                // NULL is localcomputer
            LPCTSTR groupname,                // Not NULL, groupname
            PLOCALGROUP_INFO_1& groupinfo);    // group info, must be free -> NetApiBufferFree(groupinfo);

    };

    
    
    namespace PRIVILEGE
    {
        // 현재 프로세스에 주어진 권한을 인에이블/디스에이블 시킨다.
        BOOL SetProcessPrivilege(
            LPCTSTR lpszPrivilege,            // privilege to grant
            BOOL bEnablePrivilege);            // add or remove

        // 사용자 계정에 특별한 권한을 추가시킨다.
        NTSTATUS SetPrivilegeOnAccount(
            LSA_HANDLE PolicyHandle,        // open policy handle
            PSID AccountSid,                // SID to grant privilege to
            LPWSTR PrivilegeName,            // privilege to grant (Unicode)
            BOOL bEnable);                    // enable or disable

        // 해당 유저에게 할당된 부가적인 프리빌리지를 얻어온다.
        // 일반적인 프리빌리지를 얻어올 경우는, 해당 유저가 띄운 프로세스를 이용하여
        // 아래의 GetPrivilegeFromProcessHandle 함수를 이용하여 가져온다.
        NTSTATUS EnumPrivilegeOnAccount(
            LSA_HANDLE PolicyHandle,        // open policy handle
            PSID AccountSid,                // SID to grant privilege to
            std::vector<_bstr_t>& parray);    // privileges array

        // 프로세스 핸들을 이용하여 해당 유저 이름을 얻어온다.
        BOOL GetUserFromProcessHandle(
            LPTSTR AccountName,                // account of interest
            DWORD* cbName,                    // string buffer length
            HANDLE hProcess = NULL);        // process id, NULL is owner process

        // 프로세스 아이디를 이용하여 해당 유저 이름을 얻어온다.
        BOOL GetUserFromProcessID(
            LPTSTR AccountName,                // account of interest
            DWORD* cbName,                    // string buffer length
            DWORD nProcessID = 0xFFFFFFFF);    // process id, 0xFFFFFFFF is owner process

        // 프로세스 핸들을 이용하여 해당 프로세스에 설정된 프리빌리지 목록을 얻어온다.
        BOOL GetPrivilegeFromProcessHandle(
            std::vector<_bstr_t>& parray,    // privileges array
            HANDLE hProcess = NULL);        // process id, NULL is owner process

        // 프로세스 아이디을 이용하여 해당 프로세스에 설정된 프리빌리지 목록을 얻어온다.
        BOOL GetPrivilegeFromProcessID(
            std::vector<_bstr_t>& parray,    // privileges array
            DWORD nProcessID = 0xFFFFFFFF);    // process id, 0xFFFFFFFF is owner process
    };
};

#endif // !defined(AFX_POLICY_H__8DE86AF1_C525_4546_A661_0FC4D12902EF__INCLUDED_)
invalid-file

윈도우즈 서비스 프로그램을 작성할 때
두가지 형태의 파라미터를 전달 받을 수 있습니다.

1. 서비스파일.exe  -install -u:aaa -p:pass 기타등등
2. 서비스 관리자 -> 시작 매개변수

이렇게 두가지로 전달 받을 수 있는데요..
1번과 같은 경우는 일반적인 콘솔 프로그램과 다를바가 없지요.
즉, main 의 argc, argv 파라미터를 바로 처리하면 됩니다.

2번도 사실 1번과 거의 동일합니다.
다만 파라미터를 검출하는 위치만 다를뿐 100% 같은 방식을 사용합니다.
차이점이라면 StartServiceCtrlDispatcher 에서 등록한 서비스 메인 함수에서
파라미터를 처리한다는 차이점이 있습니다. ^^;

상당히 많은 시간을 날렸네요.. ㅜㅜ

이전 내용하고 비슷한데요..
이전에 서비스계정에 이름은 있고, 암호는 없는 사용자를 처리할 때는

HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\Lsa
의 limitblankpassworduse 값을 1로 변경하면서 마무리 지었습니다.
윈도우즈 XP프로와, 서버계열에서는 아주 잘되던데..

윈도우즈 XP 홈에서는 저기까지는 잘되는데 나머지 난관이 발생하더군요..
사용자 계정 자체에 서비스로 로그온할 수 있는 보안 권한을 상승 시켜주어야 했습니다.

계정과 암호 (비어있을 경우) 정상적인데도 불구하고 서비스가 시작되지 않더군요.
서비스 관리자를 열어서 다시 서비스의 로그온 정보에서 암호를 지워주고 시작을
누르면 계정을 "서비스로 로그온 권한을 상승하였습니다." 라는 메시지가 나오면서
시작이 잘되더군요.

문제는 이걸 프로그램적으로 자동화 시켜야한다는게 문제였는데.. ^^;


#include <Ntsecapi.h>
#define TARGET_SYSTEM_NAME L"."
LSA_HANDLE GetPolicyHandle()
{
 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
 WCHAR SystemName[] = TARGET_SYSTEM_NAME;
 USHORT SystemNameLength;
 LSA_UNICODE_STRING lusSystemName;
 NTSTATUS ntsResult;
 LSA_HANDLE lsahPolicyHandle;
 
 // Object attributes are reserved, so initialize to zeros.
 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
 
 //Initialize an LSA_UNICODE_STRING to the server name.
 SystemNameLength = wcslen(SystemName);
 lusSystemName.Buffer = SystemName;
 lusSystemName.Length = SystemNameLength * sizeof(WCHAR);
 lusSystemName.MaximumLength = (SystemNameLength+1) * sizeof(WCHAR);
 
 // Get a handle to the Policy object.
 ntsResult = LsaOpenPolicy(
        &lusSystemName,    //Name of the target system.
        &ObjectAttributes, //Object attributes.
        POLICY_ALL_ACCESS, //Desired access permissions.
        &lsahPolicyHandle  //Receives the policy handle.
  );
 
 if (ntsResult != ERROR_SUCCESS)
  return NULL;
 return lsahPolicyHandle;
}

BOOL InitLsaString(PLSA_UNICODE_STRING pLsaString, LPCWSTR pwszString)
{
  DWORD dwLen = 0;

  if (NULL == pLsaString)
      return FALSE;

  if (NULL != pwszString)
  {
      dwLen = wcslen(pwszString);
      if (dwLen > 0x7ffe)   // String is too large
          return FALSE;
  }

  // Store the string.
  pLsaString->Buffer = (WCHAR *)pwszString;
  pLsaString->Length =  (USHORT)dwLen * sizeof(WCHAR);
  pLsaString->MaximumLength= (USHORT)(dwLen+1) * sizeof(WCHAR);

  return TRUE;
}

BOOL GetUserSID(PSID sid, const char* username)
{
    DWORD SidBufSz;
    char DomainNameBuf[256] = {0};
    DWORD DomainNameBufSz;
    SID_NAME_USE SNU;
    DomainNameBufSz = 256;

    if(!LookupAccountName(NULL, username, sid, &SidBufSz, DomainNameBuf, &DomainNameBufSz, &SNU))
        return FALSE;
 return TRUE;
}

BOOL AddPrivileges(PSID AccountSID, LSA_HANDLE PolicyHandle)
{
 LSA_UNICODE_STRING lucPrivilege;
 NTSTATUS ntsResult;
 
 // Create an LSA_UNICODE_STRING for the privilege names.
 if (!InitLsaString(&lucPrivilege, L"SeServiceLogonRight"))
  return FALSE;
 
 ntsResult = LsaAddAccountRights(
  PolicyHandle,  // An open policy handle.
  AccountSID,    // The target SID.
  &lucPrivilege, // The privileges.
  1              // Number of privileges.
  );               

 if (ntsResult == ERROR_SUCCESS)
  return TRUE;
 else
  return FALSE;
}

사용법은 아래와 같습니다.
 LSA_HANDLE Policy = GetPolicyHandle();
 BYTE buffer[1024] = {0};
 PSID sid = (PSID)buffer;
 if(GetUserSID(sid, "까마귀"))
  AddPrivileges(sid, Policy);

위와 같은 방법으로 사용자 계정에다가 직접 SeServiceLogonRight 권한을 넣어
주는 방법으로 해결했습니다.

자료가 없어서 헤딩좀 했는데.. 도움이 되시기를...

오류 메시지: 계정 제한 때문에 로그온할 수 없습니다

아이템에 이미지 여러개 넣기??? - 이게 정말 맞는 이해인지 모르겠다 (누가좀.. )
-----------------------------------------------------------------------------------

(iIndent 변수는 common control version 4.7 부터 적용되는 기능입니다.)
리스트 컨트롤에서 레포트 스타일일 경우 첫번째 아이템에 여러개의 이미지가 있는 것을 본적이
있는가? (전 본 기억이 없는듯.. 이것도 오늘 공부해서 써본것입니다. -_-)

저 iIndent 값은 기본적으로 0이며, 저기 숫자를 넣으면, 첫번째 아이템이
저 숫자* 아이콘의 너비 만큼 띄워져서 그려진다.
(아래의 그림은 iIdent를 1로 준 상태입니다.)

그림에서 보는 것 처럼 왼쪽에 아이콘의 너비인 16 픽셀만큼 띄워져서 그림이 그려지고. iIndent 값을 높게 주면 그 배수만큼 띄워져서 그려지게 된다.
Custom Draw나 Owner Draw를 이용하면 저기 비워놓은 공간에 먼가 작업을 해줄 수 있겠지만
그냥 쓸 때는 전혀 의미가 없어보인다. 흠..
(누구 자세히 아시는분 계시면 코멘트좀 달아주세요..)

common control version 6.0 부터는 group 이라는 기능이 지원이 되는데.. 아쉽게도 MFC 6.0
에서는 지원이 되지 않습니다. 현재 깔린 툴이 6.0 뿐이라.. 제 컴에 vs2005를 깔게되면 이 내용에
group에 관련된 내용도 추가하도록 하겠습니다. ㅋ~



위의 내용들을 이용하여 제작된 샘플이다.
-----------------------------------------------------------------------------------

이전에 다루었던 장 중에서 하나씩 시작하기의 샘플을 재 사용(-_-;;;) 하였으며 기존과 달라진 점은 공유 폴더나 단축아이콘도 이미지가 정확하게 표현된다는 점이다.

변경된 내용은 다음과 같다.

BOOL CSampleDlg::OnInitDialog()
{
    ... 중간 생략
    int ndx = 0;
    CFileFind finder;
    SHFILEINFO sfi;
    BOOL bWorking = finder.FindFile("C:\\*.*");
    while (bWorking)
    {
        bWorking = finder.FindNextFile();
        SHGetFileInfo(finder.GetFilePath(),
            0,
            &sfi,
            sizeof(SHFILEINFO),
            SHGFI_DISPLAYNAME | SHGFI_TYPENAME| SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_ATTRIBUTES);
        ndx = AddItem2(finder, sfi, ndx);
    }
    // 찾은 파일의 파일속성 정보를 얻기 위하여 SHGFI_ATTRIBUTES 플래그가 추가되었다.

    ... 중간 생략
}

int CSampleDlg::AddItem2(CFileFind& file, SHFILEINFO& sfi, int ndx)
{
    CString szTemp;
    CTime fTime;

    LVITEM item = {0};
   
    // 아이템의 상태 정보를 넣기 위하여 LVIF_STATE 플래그를 추가함.
    item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE;
    item.iItem = ndx;
    item.iSubItem = 0;
    item.pszText = sfi.szDisplayName;
    item.iImage = sfi.iIcon;
   
    // 단축 아이콘 속성일 경우.. 2번째 이미지를 오버레이 이미지로 사용함.
    if(sfi.dwAttributes & SFGAO_LINK)
    {
        item.state |= INDEXTOOVERLAYMASK(2);
        item.stateMask |= LVIS_OVERLAYMASK;
    }
    // 공뷰 폴더 속성일 경우.. 1번째 이미지를 오버레이 이미지로 사용함.
    else if(sfi.dwAttributes & SFGAO_SHARE)
    {
        item.state |= INDEXTOOVERLAYMASK(1);
        item.stateMask |= LVIS_OVERLAYMASK;
    }

    // 히든 속성일 경우는 별도이 이미지를 사용하지 않고, LVIS_CUT 상태를 이용하여
    // 흐릿하게 보이도록 함.
    if(sfi.dwAttributes & SFGAO_HIDDEN)
        item.state |= LVIS_CUT;

    ndx = m_list.InsertItem(&item);

    ... 중간 생략   
}

invalid-file

작업하다보니 단축아이콘도 만들어야 겠네.. -_-;;
마우스로 드래그만 하면 되는데 플그램으로 짜려면 왤케 이것 저것 해야하는게 많은건지..
MSDN에서 권장하는 IShellLink 인터페이스를 이용하여 제작합니다.

클래스로 만들 이유는 없는데, 이것 저것 추가될깨 있어어 그냥 껍데기를 씌웠습니다.
참고로 일반적인 헤더 외에, 아래꺼 추가되야 할겁니다.
#include <atlbase.h>
#include <comdef.h>

VC++ 6.0 SP6, 및 Platfrom SDK 2004년 버전에서 테스트됨.

헤더파일
-----------------------------------------------------------------------------------
class CFileShell 
{
public:
 CFileShell();
 virtual ~CFileShell();

    // 지정한 파일로 주어진 특수 경로에 단축아이콘을 만든다.
    BOOL CreateShortCut(const char* filepath, int nFolder, const char* dispname = NULL, const char* description = NULL, const char* workdir = NULL);

    // 특수한 경로에 주어진 이름의 폴더를 만든다.
    CString CreateSpecialForder(int nFolder, const char* forder_name);
};

1. CreateShortCut
   filepath         전체경로를 가진 파일 이름
   nFolder         CSIDL Costants 를 지칭합니다. 참고 SHGetSpecialFolderPath
   dispname      단축아이콘의 이름, 설정하기 않으면 원본 파일이름으로 대체
   description   단축아이콘 설명
   workdir          아이콘이 실행될 경로, 설정하지 않으면 원본 파일의 경로로 대체

2. CreateSpecialForder
   nFolder          CSIDL Costants 를 지칭합니다. 참고 SHGetSpecialFolderPath  
   forder_name  생성할 폴더의 이름



소스 파일
-----------------------------------------------------------------------------------
BOOL CFileShell::CreateShortCut(const char* filepath, int nFolder, const char* dispname, const char* description, const char* workdir)
{
    char TargetPath[MAX_PATH];
    CString fromPath=filepath, fromName, fromExt, ShortCutName;

    if(!SHGetSpecialFolderPath(NULL, TargetPath, nFolder, FALSE))
        return FALSE;

    HRESULT hr;
     CComPtr<IShellLink>   pISL;

    hr = pISL.CoCreateInstance( CLSID_ShellLink );
     if(FAILED(hr))
        return FALSE;

    // 단축 아이콘의 대상이 되는 파일을 설정한다.
    hr = pISL->SetPath ( filepath );
     if(FAILED(hr))
        return FALSE;

    // 주어진 소스 파일의 경로를 이용하여, 전체 패스, 이름, 확장자를 나눈다.
    int find = fromPath.ReverseFind('\\');
    if(find == -1)
        return FALSE;

    fromName = fromPath.Right(fromPath.GetLength()-find-1);
    fromPath = fromPath.Left(find+1);

    find = fromName.ReverseFind('.');
    if(find != -1)
    {
        fromExt  = fromName.Right(fromName.GetLength()-find-1);
        fromName = fromName.Left(find);
    }

    // 별도로 디스플에이용 이름을 주면 그것을 사용한다.
    if(dispname)
        fromName = dispname;

    // 별도로 수행 경로를 주면 그것을 이용한다.
    if(workdir)
        fromPath = workdir;

    // 단축 아이콘에 대한 설명을 단다.
    if(description)
    {
        hr = pISL->SetDescription ( description );
        if(FAILED(hr))
            return FALSE;
    }
   
    // 워킹 폴더를 설정한다.
    hr = pISL->SetWorkingDirectory ( fromPath );
    if(FAILED(hr))
        return FALSE;

   
    WCHAR ShortCutNameW[256] = {0};
    ShortCutName = fromPath + fromName + ".lnk";

    MultiByteToWideChar(CP_ACP, MB_COMPOSITE, ShortCutName, ShortCutName.GetLength(), ShortCutNameW, 256*sizeof(WCHAR));

    CComQIPtr<IPersistFile> pIPF( pISL );
     hr = pIPF->Save ( ShortCutNameW, FALSE );
     if ( FAILED(hr) )
        return FALSE;

    return TRUE;
}

CString CFileShell::CreateSpecialForder(int nFolder, const char* forder_name)
{
    char TargetPath[MAX_PATH];
    if(!SHGetSpecialFolderPath(NULL, TargetPath, nFolder, FALSE))
        return "";

    CString FullName = TargetPath;
    FullName += "\\";
    FullName += forder_name;

    if(!CreateDirectory(FullName, NULL))
    {
        DWORD le = GetLastError();
        if(le != ERROR_ALREADY_EXISTS)
            return "";
    }

    return FullName;
}