diff --git a/src/bin/clock/main.c b/src/bin/clock/main.c
index 86fae14..eca957e 100644
--- a/src/bin/clock/main.c
+++ b/src/bin/clock/main.c
@@ -66,7 +66,7 @@
   int min   = 0x0;
   int sec   = 0x0;
 
-  //sysTime = gettime();
+  sysTime = gettime();
 
   year = (sysTime/YEAR) + 1970;
   sysTime -= (YEAR * (year-1970));
@@ -96,6 +96,9 @@
 
 /***
  $Log$
+ Revision 1.5  2004/06/12 01:32:03  reddawg
+ clock: first so test program
+
  Revision 1.4  2004/06/04 16:15:14  reddawg
  shell: fixed a segfault bug comparing a null pointer
  clock: prints correct time now
diff --git a/src/sys/include/ubixos/ld.h b/src/sys/include/ubixos/ld.h
index c386035..6dc48ec 100644
--- a/src/sys/include/ubixos/ld.h
+++ b/src/sys/include/ubixos/ld.h
@@ -33,15 +33,18 @@
 #include <ubixos/types.h>
 
 void _ld();
-void ld(uInt32,uInt32);
+uInt32 ld(uInt32,uInt32);
+uInt32 ldFindFunc(char *);
 
 #endif
 
 /***
  $Log$
+ Revision 1.3  2004/06/12 01:27:26  reddawg
+ shared objects: yes we almost fully support shared objects
+
  Revision 1.2  2004/05/21 15:20:00  reddawg
  Cleaned up
 
-
  END
  ***/
diff --git a/src/sys/kernel/ld.c b/src/sys/kernel/ld.c
index 252e0ef..2ceb6fb 100644
--- a/src/sys/kernel/ld.c
+++ b/src/sys/kernel/ld.c
@@ -40,10 +40,14 @@
 asm(
   ".globl _ld   \n"
   "_ld:         \n"
-  "  call ld    \n"
+  "  call  ld   \n"
+  "  pop  %ecx  \n"
+  "  pop  %ecx  \n"
+  "  push %eax  \n"
+  "  ret        \n"
   );
 
-void ld(uInt32 got2,uInt32 entry) {
+uInt32 ld(uInt32 got2,uInt32 entry) {
   int               i             = 0x0;
   int               x             = 0x0;
   int               rel           = 0x0;
@@ -60,10 +64,10 @@
   binaryHeader = (elfHeader *)kmalloc(sizeof(elfHeader));
   fread(binaryHeader,sizeof(elfHeader),1,tmpFd);
 
-  kprintf("[0x%X][0x%X]\n",got2,entry);
+  //kprintf("[0x%X][0x%X]\n",got2,entry);
 
-  kprintf("binaryHeader->eType:  [%i]\n",binaryHeader->eType);
-  kprintf("binaryHeader->eEntry: [0x%X]\n",binaryHeader->eEntry);
+  //kprintf("binaryHeader->eType:  [%i]\n",binaryHeader->eType);
+  //kprintf("binaryHeader->eEntry: [0x%X]\n",binaryHeader->eEntry);
 
   sectionHeader = (elfSectionheader *)kmalloc(sizeof(elfSectionheader)*binaryHeader->eShnum);
   fseek(tmpFd,binaryHeader->eShoff,0);
@@ -73,7 +77,7 @@
   fseek(tmpFd,sectionHeader[binaryHeader->eShstrndx].shOffset,0);
   fread(shStr,sectionHeader[binaryHeader->eShstrndx].shSize,1,tmpFd);
 
-  kprintf("1");
+  //kprintf("1");
   for (i=0x0;i<binaryHeader->eShnum;i++) {
     switch (sectionHeader[i].shType) {
      case 3:
@@ -87,7 +91,7 @@
         rel = i;
         break;
       case 11:
-        kprintf("Dynamic Sym\n");
+        //kprintf("Dynamic Sym\n");
         relSymTab = (elfDynSym *)kmalloc(sectionHeader[i].shSize);
         fseek(tmpFd,sectionHeader[i].shOffset,0);
         fread(relSymTab,sectionHeader[i].shSize,1,tmpFd);
@@ -95,7 +99,7 @@
       }
     }
 
-  kprintf(".rel.plt: (%i)\n",rel);
+  //kprintf(".rel.plt: (%i)\n",rel);
   fseek(tmpFd,sectionHeader[rel].shOffset,0x0);
   elfRel = (elfPltInfo *)kmalloc(sectionHeader[rel].shSize);
   fread(elfRel,sectionHeader[rel].shSize,1,tmpFd);
@@ -105,8 +109,10 @@
   //for (i=0x0;i<sectionHeader[rel].shSize/sizeof(elfPltInfo);i++) {
 
     x = ELF32_R_SYM(elfRel[i].pltInfo);
-    kprintf("[0x%X][0x%X](%i)[%s]\n",elfRel[i].pltOffset,elfRel[i].pltInfo,x,elfGetRelType(ELF32_R_TYPE(elfRel[i].pltInfo)));
-    kprintf("relTab [%s][0x%X][0x%X]\n",dynStr + relSymTab[x].dynName,relSymTab[x].dynValue,relSymTab[x].dynName);
+    //kprintf("[0x%X][0x%X](%i)[%s]\n",elfRel[i].pltOffset,elfRel[i].pltInfo,x,elfGetRelType(ELF32_R_TYPE(elfRel[i].pltInfo)));
+    //kprintf("relTab [%s][0x%X][0x%X]\n",dynStr + relSymTab[x].dynName,relSymTab[x].dynValue,relSymTab[x].dynName);
+
+  i = ldFindFunc(dynStr + relSymTab[x].dynName);
 
   //  }
 
@@ -117,14 +123,100 @@
   kfree(shStr);
   kfree(elfRel);
  
-  asm("jmp kprintf");
+  //_current->state = DEAD;
+  //schedYield();
+  return(i);
+  }
 
-  _current->state = DEAD;
-  schedYield();
+uInt32 ldFindFunc(char *func) {
+  int               i             = 0x0;
+  int               x             = 0x0;
+  int               rel           = 0x0;
+  int               sym           = 0x0;
+  uInt32           *funcPtr       = 0x0;
+  uInt32           *reMap         = 0x0;
+  char             *shStr         = 0x0;
+  char             *dynStr        = 0x0;
+  char             *binary        = 0x0;
+  elfHeader        *binaryHeader  = 0x0;
+  elfProgramheader *programHeader = 0x0;
+  elfSectionheader *sectionHeader = 0x0;
+  elfPltInfo       *elfRel        = 0x0;
+  elfDynSym        *relSymTab     = 0x0;
+  fileDescriptor   *tmpFd         = 0x0;
+ 
+
+  //kprintf("Finding Function: [%s]\n",func);
+
+  tmpFd = fopen("libc.so","rb");
+  binary = (char *)kmalloc(tmpFd->size);
+  fread(binary,tmpFd->size,1,tmpFd);
+  fclose(tmpFd);
+ 
+  binaryHeader = (elfHeader *)binary;
+  programHeader = (elfProgramheader *)(binary + binaryHeader->ePhoff);
+  sectionHeader = (elfSectionheader *)(binary + binaryHeader->eShoff);
+
+  shStr = (char *)(binary + sectionHeader[binaryHeader->eShstrndx].shOffset);
+
+  for (i=0x0;i<binaryHeader->eShnum;i++) {
+    switch (sectionHeader[i].shType) {
+     case 3:
+        if (!kstrcmp((shStr + sectionHeader[i].shName),".dynstr")) {
+          dynStr = (char *)(binary + sectionHeader[i].shOffset);
+          }
+        break;
+      case 9:
+        rel = i;
+        break;
+      case 11:
+        //kprintf("Dynamic Sym\n");
+        relSymTab = (elfDynSym *)(binary + sectionHeader[i].shOffset);
+        sym = i;
+        break;
+      }
+    }
+
+  elfRel = (elfPltInfo *)(binary + sectionHeader[rel].shOffset);
+
+  for (i=0x0;i<sectionHeader[rel].shSize/sizeof(elfPltInfo);i++) {
+    x = ELF32_R_SYM(elfRel[i].pltInfo);
+    reMap = (uInt32 *)((uInt32)binary + elfRel[i].pltOffset);
+    switch (ELF32_R_TYPE(elfRel[i].pltInfo)) {
+      case 1:
+        *reMap += ((uInt32)binary + relSymTab[x].dynValue);
+        break;
+      case 2:
+        *reMap += ((uInt32)binary + relSymTab[x].dynValue) - (uInt32)reMap; 
+        break;
+      case 8:
+        *reMap += (uInt32)binary;
+        break;
+      default:
+        kprintf("[0x%X][0x%X](%i)[%s]\n",elfRel[i].pltOffset,elfRel[i].pltInfo,x,elfGetRelType(ELF32_R_TYPE(elfRel[i].pltInfo)));
+        kprintf("relTab [%s][0x%X][0x%X]\n",dynStr + relSymTab[x].dynName,relSymTab[x].dynValue,relSymTab[x].dynName);
+        //elfRel[i].pltOffset += (uInt32)binary;
+        break;
+      }
+    }
+
+  for (i=0x0;i<sectionHeader[sym].shSize/sizeof(elfDynSym);i++) {
+    if (!kstrcmp(func,(dynStr + relSymTab[i].dynName))) {
+      funcPtr = (uInt32 *)((uInt32)(relSymTab[i].dynValue) + (uInt32)binary);
+      //kprintf("Found function: %s In libc.so, jumping to: [0x%X:0x%X]\n",func,funcPtr,*funcPtr);
+      break;
+      }
+    }
+
+  //kfree(binary);
+  return((uInt32)funcPtr);
   }
 
 /***
  $Log$
+ Revision 1.4  2004/06/12 01:27:26  reddawg
+ shared objects: yes we almost fully support shared objects
+
  Revision 1.3  2004/05/15 02:30:28  reddawg
  Lots of changes