title: what is the equivalent of kernel32.dll in ubuntu?
body: <p>Hi I have developed sample application in c3 and cpp in windows environment. This application achieves Named pipes between these programs to communicate. I have <code>[DllImport("kernel32.dll", SetLastError = true)]</code> command in my cpp program. when i compile my c# progaram i get below error. </p>
  
  <pre><code>Enter the message
  Unhandled Exception: Unhandled Exception: System.DllNotFoundException: Unable to load DLL 'kernel32.dll': The specified module or one of its dependencies could not be found.
   (Exception from HRESULT: 0x8007007E)
     at consoleapp.NamedPipeServer.CreateNamedPipe(String pipeName, UInt32 dwOpenMode, UInt32 dwPipeMode, UInt32 nMaxInstances, UInt32 nOutBufferSize, UInt32 nInBufferSize, UInt32 nDefaultTimeOut, IntPtr lpSecurityAttributes)
     at consoleapp.NamedPipeServer.ListenForClients() in /home/niranjan/consoleapp/NamedPipeServer.cs:line 66
     at System.Threading.Thread.ThreadMain_ThreadStart()
     at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)System.DllNotFoundException: Unable to load DLL 'kernel32.dll': The specified module or one of its dependencies could not be found.
   (Exception from HRESULT: 0x8007007E)
     at consoleapp.NamedPipeServer.CreateNamedPipe(String pipeName, UInt32 dwOpenMode, UInt32 dwPipeMode, UInt32 nMaxInstances, UInt32 nOutBufferSize, UInt32 nInBufferSize, UInt32 nDefaultTimeOut, IntPtr lpSecurityAttributes)
     at consoleapp.NamedPipeServer.ListenForClients() in /home/niranjan/consoleapp/NamedPipeServer.cs:line 66
     at System.Threading.Thread.ThreadMain_ThreadStart()
     at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
  </code></pre>
  
  <p>Below is my c# files. I have created .Net core(2.0) console application in ubuntu.
  Program.cs</p>
  
  <pre><code>using System;
  
  namespace consoleapp
  {
      class Program
      {
          static void Main(string[] args)
          {
              Console.WriteLine("Hello World!");
              NamedPipeServer PServer1 = new NamedPipeServer(@"\\.\pipe\myNamedPipe1",0);
              NamedPipeServer PServer2 = new NamedPipeServer(@"\\.\pipe\myNamedPipe2",1);
  
              PServer1.Start();
              PServer2.Start();
  
              string Ms="Start";
              do
              {
                  Console.WriteLine("Enter the message");
                  Ms = Console.ReadLine();
                  PServer2.SendMessage(Ms, PServer2.clientse);
              } while (Ms != "quit");
  
              PServer1.StopServer();
              PServer2.StopServer();
          }
      }
  }
  </code></pre>
  
  <p>Below is my NamedPipeServer.cs</p>
  
  <pre><code>using System;
  using Microsoft.Win32.SafeHandles;
  using System.Text;
  using System.Runtime.InteropServices;
  using System.Threading;
  using System.IO;
  
  namespace consoleapp
  {
      public class NamedPipeServer
      {
          [DllImport("kernel32.dll", SetLastError = true)]
          public static extern SafeFileHandle CreateNamedPipe(
             String pipeName,
             uint dwOpenMode,
             uint dwPipeMode,
             uint nMaxInstances,
             uint nOutBufferSize,
             uint nInBufferSize,
             uint nDefaultTimeOut,
             IntPtr lpSecurityAttributes);
  
          [DllImport("kernel32.dll", SetLastError = true)]
          public static extern int ConnectNamedPipe(
             SafeFileHandle hNamedPipe,
             IntPtr lpOverlapped);
  
          [DllImport("kernel32.dll", SetLastError = true)]
          public static extern int DisconnectNamedPipe(
             SafeFileHandle hNamedPipe);
  
          public const uint DUPLEX = (0x00000003);
          public const uint FILE_FLAG_OVERLAPPED = (0x40000000);
  
          public class Client
          {
              public SafeFileHandle handle;
              public FileStream stream;
          }
  
          public const int BUFFER_SIZE = 100;
          public Client clientse =null;
  
          public string pipeName;
          Thread listenThread;
          SafeFileHandle clientHandle;
          public int ClientType;
  
          public NamedPipeServer(string PName,int Mode)
          {
              pipeName = PName;
              ClientType = Mode;//0 Reading Pipe, 1 Writing Pipe
  
          }
  
          public void Start()
          {
              this.listenThread = new Thread(new ThreadStart(ListenForClients));
              this.listenThread.Start();
          }
          private void ListenForClients()
          {
              while (true)
              {
  
                  clientHandle =CreateNamedPipe(this.pipeName,DUPLEX | FILE_FLAG_OVERLAPPED,0,255,BUFFER_SIZE,BUFFER_SIZE,0,IntPtr.Zero);
  
                  //could not create named pipe
                  if (clientHandle.IsInvalid)
                      return;
  
                  int success = ConnectNamedPipe(clientHandle, IntPtr.Zero);
  
                  //could not connect client
                  if (success == 0)
                      return;
  
                  clientse = new Client();
                  clientse.handle = clientHandle;
                  clientse.stream = new FileStream(clientse.handle, FileAccess.ReadWrite, BUFFER_SIZE, true);
  
                  if (ClientType == 0)
                  {
                      Thread readThread = new Thread(new ThreadStart(Read));
                      readThread.Start();
                  }
              }
          }
          private void Read()
          {
              //Client client = (Client)clientObj;
              //clientse.stream = new FileStream(clientse.handle, FileAccess.ReadWrite, BUFFER_SIZE, true);
              byte[] buffer = null;
              ASCIIEncoding encoder = new ASCIIEncoding();
  
              while (true)
              {
  
                  int bytesRead = 0;
  
                  try
                  {
                      buffer = new byte[BUFFER_SIZE];
                      bytesRead = clientse.stream.Read(buffer, 0, BUFFER_SIZE);
                  }
                  catch
                  {
                      //read error has occurred
                      break;
                  }
  
                  //client has disconnected
                  if (bytesRead == 0)
                      break;
  
                  //fire message received event
                  //if (this.MessageReceived != null)
                  //    this.MessageReceived(clientse, encoder.GetString(buffer, 0, bytesRead));
  
                  int ReadLength = 0;
                  for (int i = 0; i &lt; BUFFER_SIZE; i++)
                  {
                      if (buffer[i].ToString("x2") != "cc")
                      {
                          ReadLength++;
                      }
                      else
                          break;
                  }
                  if (ReadLength &gt; 0)
                  {
                      byte[] Rc = new byte[ReadLength];
                      Buffer.BlockCopy(buffer, 0, Rc, 0, ReadLength);
  
                      Console.WriteLine("C# App: Received " + ReadLength +" Bytes: "+ encoder.GetString(Rc, 0, ReadLength));
                      buffer.Initialize();
                  }
  
              }
  
              //clean up resources
              clientse.stream.Close();
              clientse.handle.Close();
  
          }
          public void SendMessage(string message, Client client)
          {
  
                  ASCIIEncoding encoder = new ASCIIEncoding();
                  byte[] messageBuffer = encoder.GetBytes(message);
  
                  if (client.stream.CanWrite)
                  {
                      client.stream.Write(messageBuffer, 0, messageBuffer.Length);
                      client.stream.Flush();
                  }
  
  
          }
          public void StopServer()
          {
              //clean up resources
  
              DisconnectNamedPipe(this.clientHandle);
  
  
              this.listenThread.Abort();
          }
  
      }
  }
  </code></pre>
  
  <p>below is my cpp programe.</p>
  
  <pre><code>#include &lt;stdio.h&gt;
  #include &lt;windows.h&gt;
  
  unsigned long __stdcall NET_RvThr(void * pParam) ;
  DWORD WINAPI ThreadProc() ;
  HANDLE hPipe1,hPipe2; 
  BOOL Finished;
  
  int main(int argc, char *argv[])
  {
      //Pipe Init Data
      char buf[100];
  
      LPTSTR lpszPipename1 = TEXT("\\\\.\\pipe\\myNamedPipe1"); 
      LPTSTR lpszPipename2 = TEXT("\\\\.\\pipe\\myNamedPipe2"); 
  
      DWORD cbWritten;
      DWORD dwBytesToWrite = (DWORD)strlen(buf);
  
      //Thread Init Data
      DWORD threadId;
      HANDLE hThread = NULL;
  
      BOOL Write_St=TRUE;
  
      Finished=FALSE;
  
  
  
  
      hPipe1=CreateFile(lpszPipename1,    GENERIC_WRITE ,0,NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
      hPipe2=CreateFile(lpszPipename2,    GENERIC_READ ,0,NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
  
  
       if ((hPipe1 == NULL || hPipe1 == INVALID_HANDLE_VALUE)||(hPipe2 == NULL || hPipe2 == INVALID_HANDLE_VALUE))
      { 
          printf("Could not open the pipe  - (error %d)\n",GetLastError());
  
      }
       else
       {
  
           hThread = CreateThread( NULL, 0, &amp;NET_RvThr, NULL, 0, NULL);
           do
           {
               printf ("Enter your message: ");
               scanf ("%s",buf);  
               if (strcmp (buf,"quit") == 0)
                  Write_St=FALSE;
               else
               {
                  WriteFile(hPipe1, buf, dwBytesToWrite, &amp;cbWritten, NULL);
                  memset(buf,0xCC,100);
  
               }
  
          }while(Write_St);
  
          CloseHandle(hPipe1);
          CloseHandle(hPipe2);
          Finished=TRUE;
       }
  
       getchar();
  
  
  }
  unsigned long __stdcall NET_RvThr(void * pParam) {
      BOOL fSuccess; 
      char chBuf[100];
      DWORD dwBytesToWrite = (DWORD)strlen(chBuf);
      DWORD cbRead;
      int i;
  
      while(1)
      {
          fSuccess =ReadFile( hPipe2,chBuf,dwBytesToWrite,&amp;cbRead, NULL); 
          if(fSuccess)
          {
              printf("C++ App: Received %d Bytes : ",cbRead);
              for(i=0;i&lt;cbRead;i++)
                  printf("%c",chBuf[i]);
              printf("\n");
          }
          if (! fSuccess &amp;&amp; GetLastError() != ERROR_MORE_DATA) 
          {
              printf("Can't Read\n");
              if(Finished)
                  break;
          }
      }
  }
  </code></pre>
  
  <p>I am trying to figure out ubuntu equivalent of kernal32.dll. Can someone help me to figure out this issue? Any help would be greatly appreciated. Thank you. </p>