The file [whatever] was opened and contained too long lines (more than 1,024 characters). Too long lines were wrapped and the document is set to read-only mode, as saving will modify its content.

#!/bin/sh

case $1 in
   config)
           cat <<EOM
graph_title Sound Amplitude
graph_args -l -1 --upper-limit 1
graph_vlabel Amplitude
graph_info Shows the sound amplitude values during the 1 second interval recorded discretely every minute.
mxamp.label max_ampl
mxamp.info Maximum amplitude
mnamp.label min_ampl
mnamp.info Minimum amplitude
mdamp.label mid_ampl
mdamp.info Midline amplitude
EOM
           exit 0;; 
esac

arecord -d 1 -f cd -t wav /tmp/foo.wav &> /dev/null
echo -n "mxamp.value " 
sox /tmp/foo.wav -n stat 2>&1 | grep 'Maximum amplitude' | awk '{print $3}'
echo -n "mnamp.value "
sox /tmp/foo.wav -n stat 2>&1 | grep 'Minimum amplitude' | awk '{print $3}'
echo -n "mdamp.value "
sox /tmp/foo.wav -n stat 2>&1 | grep 'Midline amplitude' | awk '{print $3}'
rm -f /tmp/foo.wav

# cat < /dev/ttyS0

# echo "Serial Connection test" > /dev/ttyS0

/ha 9.22.7.48(rw,no_root_squash) /ha 9.22.7.46(rw,no_root_squash) /ha 9.22.7.35(rw,no_root_squash) /ha 9.22.7.49(rw,no_root_squash) /ha 9.22.7.50(rw,no_root_squash)

nfsha.haw2.ibm.com:/ha /ha nfs noauto,rw,hard 0 0

# cd /ha
# tar xvfz hahbcode.tar.gz

# rpm -ivh heartbeat-pils-1.2.2-8.rh.el.3.0.i386.rpm
# rpm -ivh heartbeat-stonith-1.2.2-8.rh.el.3.0.i386.rpm
# rpm -ivh heartbeat-1.2.2-8.rh.el.3.0.i386.rpm

auth <number> <number> <authmethod> [<authkey>]

auth 2 2 crc

# File to write debug messages to debugfile /var/log/ha-debug # # # File to write other messages to # logfile /var/log/ha-log # # # Facility to use for syslog()/logger # logfacility local0 # # # keepalive: how long between heartbeats? # keepalive 2 # # deadtime: how long-to-declare-host-dead? # deadtime 60 # # warntime: how long before issuing "late heartbeat" warning? # warntime 10 # # # Very first dead time (initdead) # initdead 120 # ... # Baud rate for serial ports... # baud 19200 # # serial serialportname ... serial /dev/ttyS0 # auto_failback: determines whether a resource will # automatically fail back to its "primary" node, or remain # on whatever node is serving it until that node fails, or # an administrator intervenes. # auto_failback on # ... # # Tell what machines are in the cluster # node nodename ... -- must match uname -n node ha1.haw2.ibm.com node ha2.haw2.ibm.com # # Less common options... # # Treats 10.10.10.254 as a pseudo-cluster-member # Used together with ipfail below... # ping 9.22.7.1 # Processes started and stopped with heartbeat. Restarted unless # they exit with rc=100 # respawn hacluster /usr/lib/heartbeat/ipfail

ha1.haw2.ibm.com 9.22.7.46 Filesystem::nfsha.haw2.ibm.com:/ha::/ha::nfs::rw,hard httpd

# chmod 775 /ha/www
# chmod 775 /ha/www/html

# mv /var/www/html /var/www/htmllocal

# ln -s /ha/www/html /var/www/html

# cp /ha/hahbcode/www/index.html /var/www/html

# cp /ha/hahbcode/www/hostname.html /var/www/html

# ln -s /var/www/htmllocal/hostname.html /ha/www/html/hostname.html

# /etc/rc.d/init.d/heartbeat start

Hello!!! I am being served from a High Availability Cluster ha.haw2.ibm.com

Hello!!! I am being served from a node ha1.haw2.ibm.com in a High Availability Cluster ha.haw2.ibm.com

# /etc/rc.d/init.d/heartbeat stop

Hello!!! I am being served from a High Availability Cluster ha.haw2.ibm.com

Hello!!! I am being served from a node ha2.haw2.ibm.com in a High Availability Cluster ha.haw2.ibm.com

find <GUESS_BRANCH> -name <QUOTED_NAME>

grep demangle /usr/lib/*.so 
grep demangle /usr/lib/*.a

grep demangle /lib/*.so 
grep demangle /lib/*.a

grep demangle /usr/lib/*.so
  Binary file /usr/lib/libstdc++.so matches

grep demangle /usr/lib/*.a
  Binary file /usr/lib/libiberty.a matches
  Binary file /usr/lib/libstdc++.a matches
  Binary file /usr/lib/libsupc++.a matches

grep demangle /lib/*.so
  no hits

grep demangle /lib/*.so
  no hits

# Compare objdump of static and dynamic symbols:
  objdump -tT /usr/lib/libstdc++.so | sed '/demangle/!d'
  objdump -tT /usr/lib/libiberty.a | sed '/demangle/!d'

Legend:
  g = 'global'
  F = 'function'
  O = 'object' (or data/struct, etc.)
  .text = executable code section, read only
  .data = initialized data, read-write
  .bss  = uninitialized data, 
  *UND* = undefined, requires definition from elsewhere
  [etc.]

// file: main.cpp 
// executable: demangle
#include <stdio.h>    // FILE stuff, printf(), sprintf(), etc.
#include <malloc.h>   // memory allocation
#include <string.h>   // strings and block comparisons and moves
#include <demangle.h> // the main function

int main(int argc, char** argv)
{
  // TODO: a more meaningful error handler
  if(argc < 2)
    exit(1); 
    
  // extern char * cplus_demangle (const char *mangled, int options);
  int flags = DMGL_PARAMS | DMGL_VERBOSE | DMGL_TYPES;
  char* s = cplus_demangle_v3(argv[1], flags);
  if(s)
    printf("%s\n", s);
  else
    printf("%s(...)\n", argv[1]); // or write a "can't demangle" warning.
  return 0;
}

  # objdump sees: 000d3db0  w   DO .data 00000008  CXXABI_1.3  _ZTIw
  $> demangle _ZTIw
  typeinfo for wchar_t
  
  # And I have always wondered what a "C1ERKSs" was, haven't you?
  $> demangle _ZNSt14overflow_errorC1ERKSs
  std::overflow_error::overflow_error(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
  # and now I regret having asked. :-)

$ echo "you'll never get me, coppa" >> anonymous
$ tail -f anonymous
you'll never get me, coppa

$ rm anonymous 
$ ls anonymous
ls: cannot access anonymous: No such file or directory

$ ps -e | grep tail
 9868 pts/0    00:00:00 tail
$ cd /proc/9868/fd
$ ls -lh
total 0
lrwx------ 1 cmhoward cmhoward 64 Feb  5 19:57 0 -> /dev/pts/0
lrwx------ 1 cmhoward cmhoward 64 Feb  5 19:57 1 -> /dev/pts/0
lrwx------ 1 cmhoward cmhoward 64 Feb  5 19:56 2 -> /dev/pts/0
lr-x------ 1 cmhoward cmhoward 64 Feb  5 19:57 3 -> /scratch/cmhoward/anonymous (deleted)
lr-x------ 1 cmhoward cmhoward 64 Feb  5 19:57 4 -> anon_inode:inotify
$ echo "nobody knows the trouble I've seen..." >> 3
$ tail -f 3
you'll never get me, coppa
nobody knows the trouble I've seen...

// main.cpp -> asm2cxx
// Interfacing asm with C++ example

#include <stdio.h>  // printf()
#include <string.h> // str*()
#include <malloc.h> // malloc(), free()
#include <stdlib.h> // system()

void dbg(){}

class Interp
{
  private:
    char* parsebuf;
    const char* command;
  public:
    Interp();
    ~Interp();
    char* get_parsebuf() { return parsebuf; }
    void read_command();
    void do_command();
};

// constructor/destructor
Interp::Interp() { parsebuf = (char*) malloc(4096); }
Interp::~Interp() { if(parsebuf) free(parsebuf); parsebuf = 0; }

// some class functions we can call from asm through jumps
// defined in C.
void Interp::read_command() { fgets(parsebuf, 4096, stdin); }

// does a system call, this will NOT do chdir though.  That 
// has to be handled by a direct call to chdir().
void Interp::do_command() { 
  if(!system(parsebuf))
    printf(" [OK]\n");
  else
    printf(" [???]\n");
}

extern "C"
{
  // Takes an object pointer on the stack,
  // returns 0 to exit, else loop
  void code_section();
  int asm2cxx(Interp* o);
  void print_prompt();
} // extern "C"

int main(int argc, char** argv)
{
  dbg();
  Interp* o = new Interp();
  
  while(1)
  {
    int more;
    print_prompt();
    more = asm2cxx(o);
    if(! more)
    {
      printf("Exiting asm2cxx demo\n");
      break;
    }
  }
  return 0;
}

static char exit_str[] = {"exit"};

extern "C"
{
  void c2cxx_read_command(Interp* o) { o->read_command(); }
  void c2cxx_do_command(Interp* o) { o->do_command(); }
  const char* c2cxx_get_parsebuf(Interp* o) { return o->get_parsebuf(); }
}

// asm.s - 32 bit intel assembler, ATT syntax

/* notes:
 *    
 * C and C++ style comments are OK anywhere except following 
 * a mnemonic unless the mnemonic is terminated with a semicolon.
 * Hashmark '#' comments ala sh comments can be put anywhere.
 *
 * As in C declarations can be separate from definitions for
 * .data and .text (code).  And no external lookups are done 
 * until link-time, so including headers is not necessary.
*/

//////////////////////////////////////
// data section
  .data
  .align 4;

promptstr:
  .string "\nASM2CXX: "
exitstr:
  .string "exit"

//////////////////////////////////////
// code declarations

  .text;
  .align 4;
  
// void print_prompt();
.globl print_prompt
.type print_prompt, @function

// int asm2cxx(Interp* o);
.globl asm2cxx
.type asm2cxx, @function

//////////////////////////////////////
// code definitions

print_prompt:
  push  $promptstr;
  call  printf;
  pop  %eax;          // clean up stack
  ret;

asm2cxx:
  // grab object ptr and save regs
  mov 4(%esp), %eax; 
  pushl %ebx;   pushl %edi;  pushl %esi;
  
  // ebx = o
  movl  %eax, %ebx

  // reserve enough stack area for up to 4 call params en bloc
  subl  $16, %esp
      
  // get the command pointer (ebx = obj ptr)
  // set param[0] = obj ptr
  movl  %ebx, (%esp)
  call  c2cxx_read_command    ### call C++ through C

  // eax = command string
  // skip whitespaces
  cmpb  $32, (%eax)
  jg  .L_end_skip_leading
.L_begin_skip_leading:
  addl  $1, %eax
  cmpb  $32, (%eax)
  jle .L_begin_skip_leading
.L_end_skip_leading:

  // if command = "exit"
  movl  $exitstr, %edi;  movl  $4, %ecx;   movl  %eax, %esi;  repz cmpsb
  jne .L_not_exit
      
  movzbl  4(%eax), %edx
  leal  4(%eax), %ecx; // step to end of "exit" if match
  testb %dl, %dl
  je .L_exit

  // and trailing whitespaces ok (ecx is our str ptr)
  jmp .L_chk_ws
.L_next_ws:
  addl  $1, %ecx
  movzbl  (%ecx), %edx
  testb %dl, %dl
  je  .L_exit
.L_chk_ws:
  cmpb  $32, %dl
  jle .L_next_ws

.L_exit:
  // return FALSE (don't loop again) if end of input
  xorl  %eax, %eax
  testb %dl, %dl
  je  .L_clean_stack

  // do the command and return TRUE (loop again)
.L_not_exit:
  // set param[0] = obj ptr
  movl  %ebx, (%esp)
  call  c2cxx_do_command  ### call C++ through C

  // return TRUE
  movl  $1, %eax

.L_clean_stack:
  addl  $16, %esp
  popl  %esi;  popl  %edi;  popl  %ebx  
  ret

  if(argc > 2)
  {
    if(strstr(argv[1], "++")) // CHANGED THIS -rs

    //  int* pi = &signum;
    //  int z = pi[2]; 
    //  z += 20;
    //  sig_context* ps = (void*)z;

    // translation: get parameter 3.
    // set sig_context pointer to param3 + 5 stack_cells

    asm(
        "   lea    8(%ebp),%eax;"         // int *eax = &signum
        "   mov    8(%eax),%eax;"         // signum, p2, pointers
        "   lea    20(%eax),%eax;"        // pointers+20 -> psig_context
        "   mov    %eax,psig_context;"    // and now we're set to go...
       );

  // Since the first 6 parameters are held in registers in an ix_64 cpu
  // getting the first pointer address can't be done.
    //  int* pi = &signum; <-- will not work in 64 bits
    //  int z = pi[2];     <-- can't be done because of prob above
    //  z += 20; // 5 cells
    //  sig_context* ps = (void*)z;
  
    // translation: get parameter 3.
    // set sig_context pointer to param3 + 5 stack_cells
    // For 64 bits we do it this way...
  
  // so we need another way to get the third parameter, and for this 
  // we'll use a C-callable asm rountine called get_rdx() which just
  // returns rdx is rax.
  
    void**p;
    
    p = (void**)get_rdx();
    p+=5;
    psig_context = (sig_context*)p;

typedef struct _sig_context {
    // this comes in on the stack during an exception
    unsigned short gs, __gsh;
    unsigned short fs, __fsh;
    unsigned short es, __esh;
    unsigned short ds, __dsh;
    unsigned long edi;
    unsigned long esi;
    unsigned long ebp;
    unsigned long esp;
    unsigned long ebx;
    unsigned long edx;
    unsigned long ecx;
    unsigned long eax;
    unsigned long trapno;
    unsigned long err;
    unsigned long eip;
    unsigned short cs, __csh;
    unsigned long eflags;
    unsigned long esp_at_signal;
    unsigned short ss, __ssh;
    void* fpstate; // n/u for now
    unsigned long oldmask;
    unsigned long cr2;
    // theres more if you need it but you will have to find the header 
    // in the kernel dev stuff if you want it
}sig_context;

typedef struct _sig_context {
  // this comes in on the stack during an exception
  unsigned long r8;
  unsigned long r9;
  unsigned long r10;
  unsigned long r11;
  unsigned long r12;
  unsigned long r13;
  unsigned long r14;
  unsigned long r15;
  unsigned long rdi;
  unsigned long rsi;
  unsigned long rbp;
  unsigned long rbx;
  unsigned long rdx;
  unsigned long rax;
  unsigned long rcx;
  unsigned long rsp;
  unsigned long rip;
  unsigned long efl;
  unsigned long csgsfs;   /* actually short cs, gs, fs, __pad0.  */
  unsigned long err;
  unsigned long trapno;
  unsigned long oldmask;
  unsigned long cr2;
  // theres more if you need it but you will have to find the header 
  // in the kernel dev stuff if you want it
}sig_context;

// main.c for seh-test

#include <stdio.h>  // printf() 
#include <signal.h> // signal()

void dbg(){}

void exception_dispatcher(int signum);

static int mem_test_var;

static struct sigaction new_action;

void init_sighandler(void (*fn)(int))
{
  new_action.sa_handler = fn;
  sigemptyset (&new_action.sa_mask);
  new_action.sa_flags = SA_SIGINFO;
  // we only need to catch segfault, but let's anticipate
  // playing with any signal between 1 and 16.
  int i;
  for( i = 1; i < 16; i++ )
  {
    sigaction(i, &new_action, 0);
  }    
}


// sets mem_test_var = 1 if no access, 2 if read only, 3 if read-write.
void mem_test(void* address);
void print_result(const char* name);

int main(int argc, char** argv)
{
  dbg();
  init_sighandler(exception_dispatcher);
  
  const char* ro_test = "some text";   // read only
  char rw_test[4];                     // readwrite
  char* none_test = 0;                 // inaccessable
  
  mem_test((void*)ro_test);
  print_result("ro_test");
  
  mem_test((void*) rw_test);
  print_result("rw_test");
  
  mem_test((void*) none_test);
  print_result("none_test");
  
  return 0;
}

typedef struct _sig_context {
    // this comes in on the stack during an exception
  unsigned short gs, __gsh;
  unsigned short fs, __fsh;
  unsigned short es, __esh;
  unsigned short ds, __dsh;
  unsigned long edi;
  unsigned long esi;
  unsigned long ebp;
  unsigned long esp;
  unsigned long ebx;
  unsigned long edx;
  unsigned long ecx;
  unsigned long eax;
  unsigned long trapno;
  unsigned long err;
  unsigned long eip;
  unsigned short cs, __csh;
  unsigned long eflags;
  unsigned long esp_at_signal;
  unsigned short ss, __ssh;
  void* fpstate; // n/u for now
  unsigned long oldmask;
  unsigned long cr2;
    // theres more if you need it but you will have to find the header 
    // in the kernel dev stuff if you want it
}sig_context;


static sig_context* psig_context; // a pointer we can get at in asm

void asm_section() // creates a place for asm function(s) in a C file
{
  asm(
      // the asm declaration, code section, local (static)
      ".text;\n"
      ".align 4;\n"
      ".local mem_test;\n"
      ".type mem_test, @function;\n"
      "mem_test:\n"                 // (that's a colon)
      "movl $0, %eax;\n"            // clear and get const 0
      "movl %eax, mem_test_var;\n"  // init test type = 0
      "movl 4(%esp), %edx;\n"       // get address
      "incl mem_test_var;\n"        // crash on read = 1
      "movb (%edx), %al;\n"         // read one byte
      "incl mem_test_var;\n"        // crash on write = 2
      "movb %al, (%edx);\n"         // write it back 
      "incl mem_test_var;\n"        // read/write ok = 3
      "ret;\n"
     );
}

void exception_dispatcher(int signum)
{
  // TODO: filter and handle signals by signum.
  
  // This function will always have the stack frame 
  // so if it's written in asm, include that in your
  // code.
  
  asm(
      "   lea    8(%ebp),%eax;"         // int *eax = &signum
      "   mov    8(%eax),%eax;"         // signum, p2, pointers
      "   lea    20(%eax),%eax;"        // pointers+20 -> psig_context
      "   mov    %eax,psig_context;"    // and now we're set to go...
     );
  
  // Model the cpu doing a 'ret' opcode in C.  
  // See the disassembly if you aren't familiar with 
  // how C deals with operand sizes.
  
  void** esp = (void**)psig_context->esp; // stack ptr
  void* eip = *esp++;                     // pop eip
  
  // and update the context from our modeled registers
  psig_context->esp = (long)esp;
  psig_context->eip = (long)eip;  
}

void print_result(const char* name)
{
  const char* result;
  switch(mem_test_var)
  {
    case 1:
      result = "inaccessible";
      break;
    case 2:
      result = "read only";
      break;
    case 3:
      result = "read write";
      break;
    default:
      result = "unknown";
  }
  printf("%s:\tmemory is %s\n", name, result);
}

makefile-creator seh-test # straight C, output name is seh-test
make clean; make          # generate the app
seh-test                  # and run it

$> seh-test
ro_test:        memory is read only
rw_test:        memory is read write
none_test:      memory is inaccessible

// main.c
#include <stdio.h>

void  dbg(){}

// macros to define an asm function
#define __L(name) \
  ".text;\n" \
  ".globl "#name";\n" \
  ".type " #name", @function;\n" \
  ""#name":"

#define FUNCTION(name) \
  asm( \
  ".text;\n" \
  ".align 4\n" \
  __L(name) \
  ); \
  asm

// iterative tester, first test (long a), then (long a, long b) and so forth
// to see the pattern using a debugger or using 'objdump -d asm64-test'.
long c_test(long a, long b, long c, long d, long e, long f, long g, long h)
{
  return g;  // offset 0x10 from ebp = offset 8 in asm code below
}


long rval;

long asm_test(long a, long b, long c, long d, long e, long f, long g, long h);

void asm_section()
{
  FUNCTION(asm_test)
  (
      "movq 8(%rsp), %rax;\n" // get first item above the return address off the stack
      "movq %rax, rval(%rip)\n;"
      "ret;\n"
  );
}
 
int main(int argc, char** argv)
{
  dbg();
  //  test code ------->
  // rdi = 1, rsi = 2,  rdx = 3, rcx = 4, r8 = 5, r9 = 6, 
  
  long n1 = c_test(1, 2, 3, 4, 5, 6, 7, 8);
  printf("C test  : first item on machine stack is #%d in (1,2,3,4,5,6,7,8)\n", n1);
  
  long n2 = asm_test(1,2,3,4,5,6,7, 8);
  printf("ASM test: first item on machine stack is #%d in (1,2,3,4,5,6,7,8)\n", n2);
  // <------- test code
  return 0;
}

makefile-creator asm64-test
edit Makefile # and change the -m32 switches to -m64
make

asm64-test

rdi = 1, rsi = 2,  rdx = 3, rcx = 4, r8 = 5, r9 = 6

E = 01000101
e = 01100101

Bit 6	Bit 5	Group
0	0	Control Characters
0	1	Digits & Punctuation
1	0	Upper Case & Special
1	1	Lower Case & Special

const char* usage_str =
    "Usage: %s [switches] dir\n"
    "\n"
    "  For use with 'configure' based installations to install into\n"
    "  prefix=/UsR and then converted to a binary installation into the\n"
    "  real /usr folder.\n"
    "\n"
    "  How: \n"
    "  This application scans and replaces the path UsR found in elf\n"
    "  binaries and other files allowing installation into /UsR and\n"
    "  then changing the path to a real system directory.\n"
    "\n"
    "  Several checks are performed on the text before committing to\n"
    "  a change and it can be first (without the --armed switch( which \n"
    "  you can verify in a hex viewers before creating the binary \n"
    "  installation.  \n"
    "\n"
    "  Is it fool proof?  Pretty close, but some caution is advised.\n"
    "  Keeping a backup of folders and doing a test installation on\n"
    "  your own system to see what changes is just good sense and as\n"
    "  usual, no warantees at this end.  Just best wishes and a bit\n"
    "  of optimism considering the alternatives which you might want\n"
    "  to check out if there are any.\n"
    "\n"
    "  Switches:\n"
    "    [none]          - prints file names and offsets where /UsR is\n"
    "                      found and set to be changed in an armed run.\n"
    "                      Shows a bit of context (hex/ascii dump) and\n"
    "                      can also be used to view in a hex editor.\n"
    "\n"
    "                      Includes text files and other other binaries\n"
    "                      in the scan in addition to elf binaries (the\n"
    "                      default).\n"
    "\n"
    "    --armed         - commit to changes reported in dry run (default).\n"
    "\n"
    "    --elf | --elf-only\n"
    "                    - Only change rpaths and other occurrances of \n"
    "                      UsR in a path context in elf binaries (libs\n"
    "                      and executables).\n"
    "\n"
    "  Tips: \n"
    "    * After intalling into prefix=/UsR, tar up the /UsR directory\n"
    "    where it is before moving the files to where you will build\n"
    "    your package to avoid broken links and missing files, etc.\n"
    "\n"
    "    * If after running with no switches and none of the non-elf files\n"
    "      need to be modified, you can add the '--elf' switch for the \n"
    "      armed run.\n"
    "\n"
    "    * For use as a non-root user, any directory tree is assumed to \n"
    "      have come from and is intended to be installed at root.  You \n"
    "      may run this before or after having moved the files.  Don't\n"
    "      run it in the source though. :-)\n"
    "\n"
    "  Note: The /UsR (prefix) folder you install into using the initial\n"
    "  compilation and installation must be located at the root of the\n"
    "  file system.  The number of letters in the path is critical to\n"
    "  this application's ability to accurately modify 'rpath' and other\n"
    "  text after you have installed into the /UsR dummy directory.\n"
    "\n"
    "    Copyright (C) 2012, Rainbow Sally\n"
    "\n"
    "    Released under the GPL license.\n"
    "\n"
    ;

// uses slist functions
#define VERSION "1.3.0"

// UsR2usr.cpp

#include <stdio.h>    // printf, sprintf, etc.
#include <stdlib.h>   // exit()
#include <unistd.h>   // tons of stuff
#include <malloc.h>   // memory allocation
#include <string.h>   // strings and block comparisons and moves
#include <ctype.h>
#include "version.h"
#include "slist.h"

void dbg(){}          // a breakpoint for kdbg.exec

// simplified syntax for comparing and moving str/mem
// case insensitive
#define streq(a, b) (strcasecmp(a, b) == 0)

// case sensitive
#define memeq(buf, str) \
  (memcmp(buf, str, strlen(str)) == 0)

// move a string minus terminator
#define memstrcpy(buf, str) \
  memcpy(buf, str, strlen(str))

enum
{
  FILETYPE_ELF = 101,
  FILETYPE_TEXT,
  // others...
  FILETYPE_BINARY
};

static char errmsg[256];
typedef struct
{
  char* buf;
  size_t buflen;
  bool armed_flag; // = 0;
  bool elf_only_flag; // = 0;
  bool pass_filter;
  int filetype; // elf, text, other binary..
  int scan_number; // = 0; // true if first file in scan
  const char* filename;
}VARS;

VARS* global_vars;
// #define obj (*global_vars)

VARS* vars_new()
{
  VARS* vars = (VARS*)malloc(sizeof(VARS));
  memset(vars, 0, sizeof(VARS));
}

void vars_delete(VARS**po)
{
  // destructor
  if(*po)
    free(*po);
  *po = 0;
}

void obj_setPassFilter(VARS* o);
void obj_setFiletype(VARS* o);

// returns count of replacements proposed
int obj_scanAndReplace(VARS* o);

// returns 0 on success, else fatal
int obj_processFile(VARS* o, const char* filename);


const char* appname;

int usage(int errcode);
int show_version(int errcode);
int do_errmsg(int errcode, const char* msgfmt, const char* errvar);
int reorder_args(int argc, char** argv);

int main(int argc, char** argv)
{
  dbg();
    
  appname = basename(argv[0]);
  int arg_offset = reorder_args(argc, argv);
  
  if(argc == 1)
    return usage(1);
  
  if(streq(argv[1], "--help"))
    return usage(0);

  VARS* o = vars_new();
  
  for(int i = 1; i <= arg_offset; i++)
  {  
    if(streq(argv[i], "--armed"))
      o->armed_flag = 1;
    else if(memeq(argv[i], "--elf")) // --elf | --elf-only
      o->elf_only_flag = 1;
    else if(streq(argv[i], "-v") || streq(argv[i], "--version"))
      return show_version(0);
    else
    {
      fprintf(stderr, "Unknown switch '%s'\n", argv[i]);
      exit(1);
    }
  }

  const char* dirname = argv[1 + arg_offset];
  
  // get list of files in dirname
  char tmpbuf[4096];
  char** filelist = slist_new();
  int numfiles;
  
  sprintf(tmpbuf, "find %s -type f", dirname);
  slist_readPipe(&filelist, tmpbuf);
  
  numfiles = slist_count(filelist);  
  
  // tell type of scan
  if(numfiles > 0)
  {
    printf("\n");
    sprintf(tmpbuf, "Scan type selected = [%s, %s]",
         o->armed_flag ? "ARMED" : "check",
         o->elf_only_flag ? "ELF only" : "all");
    printf("%s\n", tmpbuf);
    for(int i = 0; i < strlen(tmpbuf); i++)
      printf("-");
    printf("\n");
  }
  else
  {
    printf("%s: No files!\n", appname);
    return 1;
  }
  
  for(int i = 0; i < numfiles; i++)
  {
    const char* filename = filelist[i];
    int fatal = obj_processFile(o, filename);
    if(fatal)
      return 1;
    
  }
  vars_delete(&o);
  return 0;
}

int show_version(int errcode)
{
  printf("UsR2usr version %s", VERSION);
  return errcode;
}


int do_errmsg(int errcode, const char* msgfmt, const char* errvar)
{
  if(errvar == 0)
    errvar = (char*)"";
  sprintf(errmsg, msgfmt, errvar);
  perror(errmsg);
  return errcode;
}


int usage(int errcode)
{
#include "usage_str.dat" // has one %s format for appname
             
  // test for presence of kdialog for the usage message
  char syscmd[4096];
  sprintf(syscmd, "kdialog -v >/dev/null 2>&1");
  int err = system(syscmd);

  if(err)
    printf(usage_str, appname);
  else
  {
    char msg[4096];
    sprintf(msg, usage_str, appname);
    sprintf(syscmd, "kdialog -msgbox \"%s\" -title \"Usage     \"" , msg);
    err = system(syscmd);

    if(err)
      printf(usage_str, appname);
  }
  return errcode;
}

int reorder_args(int argc, char** argv)
{
  // make literal copy of argv in temporary list
  char** tmp_args = (char**)malloc(argc * sizeof(char**));
  memcpy(tmp_args, argv, argc * sizeof(char**));
  
  int cnt = 1; // current copy back number, app path is at [0] still
  int nswitches = 0; // the value to return
  
  // copy switches back first
  for(int i = 1; i < argc; i++)
    if(tmp_args[i][0] == '-')
      argv[cnt++] = tmp_args[i];
  
  nswitches = cnt - 1; // number of actual switches
  
  // copy non-switches back next
  for(int i = 1; i < argc; i++)
    if(tmp_args[i][0] != '-')
      argv[cnt++] = tmp_args[i];
  
  free(tmp_args);
  return nswitches;
}


void obj_setFiletype(VARS* o)
{
  do
  {
    if(memeq(o->buf+1, "ELF"))
       printf("");
    if(memeq(o->buf, "\177ELF"))
      printf("");
    if(o->buflen >= 4)
    {
      if(memeq(o->buf, "\177ELF"))
      {
        o->filetype = FILETYPE_ELF;
        break;
      }
    }
    int testlen = 32;
    int ascii_flag = 1;
    if(o->buflen < testlen)
      testlen = o->buflen;
    for(int i = 0; i < testlen; i++)
    {
      if(!isascii(o->buf[i]))
      {
        ascii_flag = 0;
        break;
      }
    }
    if(ascii_flag && (testlen > 0))
    {
      o->filetype = FILETYPE_TEXT;
      break;
    }
    // other checks..
    // default
    o->filetype = FILETYPE_BINARY;       
  }while(0);
}

// returns 0 on success, else fatal
int obj_processFile(VARS* o, const char* filename)
{
  o->filename = filename;
  FILE* fp = fopen(filename, "rb+");
  if(! fp)
    return do_errmsg(1, "Can't open file '%s'", o->filename);
        
  fseek(fp, 0, SEEK_END);
  o->buflen = ftell(fp);
  fseek(fp, 0, SEEK_SET);    
    
  o->buf=(char*)malloc(o->buflen);
  if(! o->buf)
    return do_errmsg(1, "Can't allocate memory", 0);
      
  fread(o->buf, 1, o->buflen, fp);
    
  // check file type and set accessible flag to indicate 
  // whether this is selected to be modified or not.
  obj_setFiletype(o);  
  obj_setPassFilter(o);
      
  // scan for text /UsR or UsR/ and replace with 
  // /usr or usr/
    // save file only if not just checking and
    // filetype matches user selection
  if(o->pass_filter)
  {
    int count = obj_scanAndReplace(o);
    if(count < 0)
      return do_errmsg(1, "Can't scan file '%s'", o->filename);
    
    int nbytes; // for debugger
    if(o->armed_flag)
    {
      //fseek(fp, 0, SEEK_SET);
      fseek(fp, 0, SEEK_SET);    
      nbytes = fwrite(o->buf, 1, o->buflen, fp);
    }
  }
  fclose(fp);
  free(o->buf);
  return 0;
}

void obj_dumpContext(VARS* o, char* bufptr, bool change)
{
  if(! o->scan_number)
    printf("\n");
  
  o->scan_number += 1;

  // hex dump 16 bytes of context
  
  unsigned char* cptr;
  int dumplen = 16;
  
  cptr = (unsigned char*)bufptr - 6;
  if((char*)cptr < o->buf)
    cptr = (unsigned char*)o->buf;
  
  char* bufend = o->buf + o->buflen;
  if(cptr > (unsigned char*)bufend)
    dumplen = (unsigned char*)bufend - cptr;
  
  if(!change)
    printf("NOT ");
  
  printf("To change in '%s' at offset 0x%0X:\n", o->filename, bufptr - o->buf);
  for(int i = 0; i < dumplen; i++)
  {
    printf("%0.2X ", cptr[i]);
  }
  printf(" %s\"...", change ? "CHG: \x1b[1;31m" : "---- \x1b[37m");
  for(int i = 0; i < dumplen; i++)
  {
    if(isprint(cptr[i]))
      printf("%c", cptr[i]);
    else
      printf(".");
  }
  printf("...\"\x1b[0;30m\n\n");
}


void obj_showStatus(VARS* o, char* bufptr, bool change)
{
  if(o->armed_flag)
  {
    printf("Found 'UsR' in '%s' at 0x%X %s\n", o->filename, bufptr - o->buf, change ? "(CONVERTED)" : "(No Change)");
  }
  else
  { 
    obj_dumpContext(o, bufptr, change);
  }
}


// returns number of changes made.
int obj_scanAndReplace(VARS* o)
{
  int count = 0;
  char* ptr = o->buf;
  char* bufend = ptr + o->buflen;

  int found;
  found = 0;
  while(ptr < bufend)
  {
    found = 0;            // flag found in context
    const char* replstr = 0;   // flag and string to skip
    do{
      // UsR in correct context
      ///
      // check for any all at once
      if(strchr("/U\'\"", *ptr))
      {
        if(*ptr == 'U')
        {
          static const char* this_str = "UsR/";
          if(memeq(ptr, this_str))
          {
            found++;
            replstr = "usr/";
          }
          else if(memeq(ptr, "UsR"))
          {
            replstr = "UsR";            
          }
        }
        else if(*ptr == '/')
        {
          static const char* this_str = "/UsR";
          if(memeq(ptr, this_str))
          {
            found++;
            replstr = "/usr";
          }
        }          
        else if(*ptr == '\'')
        {
          static const char* this_str = "\'UsR\'";
          if(memeq(ptr, this_str))
          {
            found++;
            replstr = "\'usr\'";
          }
        }          
        else if(*ptr == '\"')
        {
          static const char* this_str = "\"UsR\"";
          if(memeq(ptr, this_str))
          {
            found++;
            replstr = "\"usr\"";
          }
        }
      } // if(strchr
      
      //  found & show copy count steps
      //        | (replstr & steps | 1step)
      if(found)
      {
        obj_showStatus(o, ptr, true); // and show 'change'
        memstrcpy(ptr, replstr);
        ptr += strlen(replstr);
        count++;
      }
      else // not found
      {
        if(replstr)
        {
          obj_showStatus(o, ptr, false); // show 'no change'
          ptr += strlen(replstr);
        }
        else 
          ptr++; // step 1
      }      
      
    }while(0); // do
  } // while(bufptr...)
  return count;
}

void obj_setPassFilter(VARS* o)
{
  // if filetype = elf or --all then true else false
  o->pass_filter = false;
  if(o->filetype == FILETYPE_ELF)
    o->pass_filter = true;
  else if(!o->elf_only_flag)
    o->pass_filter = true;
}

makefile-creator c++ UsR2usr

make

[elf files only]
UsR2usr test --elf-only
UsR2usr test --elf-only --armed
UsR2usr test --elf-only
[verified all changes made and other strings untouched]

[all files]
UsR2usr test
UsR2usr test --armed
UsR2usr test
[verified]

void reverseLinkedList ()
{
	linkedList *pointer1;
	linkedList *pointer2;
	
	pointer1 = NULL;
	pointer2 = head->next;
	
	while (pointer2 != NULL)
	{
		head->next = pointer1;
		
		pointer1     = head;
		head         = pointer2;
		pointer2     = pointer2->next;
	}
	
	/*
             When
		`pointer1` reaches the last but one node,
		`head` reaches the last node,
		`pointer2` reaches the null,
		
		the direction change of the head node's next pointer is still pending, so
	*/
	head->next = pointer1;

	/* 
             To include the direction change of the head node's next pointer (when it 
	        reaches the end of the list) in the while loop itself, simply store the head 
        	pointer in another temporary pointer i.e pointerX. The condition in the while 
	        loop then will be `while (pointerX != NULL)` and you'll have to check the value
        	of the `pointer2` before moving it again, like 
	        `if (pointer2 != NULL) pointer2 = pointer2->next;`
        */
}

Attached Files

reverseLinkedList.txt (1.8 KB, 2 views)

#!/bin/bash

# Reset terminal to current state when we exit.
trap "stty $(stty -g)" EXIT

# Disable echo and special characters, set input timeout to 0.2 seconds.
stty -echo -icanon time 2 || exit $?

# String containing all keypresses.
KEYS=""

# Set field separator to BEL (should not occur in keypresses)
IFS=$'\a'

# Remind user to press ESC to quit.
echo "Press Esc to quit." >&2

# Input loop.
while [ 1 ]; do

    # Read more input from keyboard when necessary.
    while read -t 0 ; do
        read -s -r -d "" -N 1 -t 0.2 CHAR && KEYS="$KEYS$CHAR" || break
    done

    # If no keys to process, wait 0.05 seconds and retry.
    if [ -z "$KEYS" ]; then
        sleep 0.05
        continue
    fi

    # Check the first (next) keypress in the buffer.
    case "$KEYS" in
      $'\x1B\x5B\x41'*) # Up
        KEYS="${KEYS##???}"
        echo "Up"
        ;;
      $'\x1B\x5B\x42'*) # Down
        KEYS="${KEYS##???}"
        echo "Down"
        ;;
      $'\x1B\x5B\x44'*) # Down
        KEYS="${KEYS##???}"
        echo "Left"
        ;;
      $'\x1B\x5B\x43'*) # Down
        KEYS="${KEYS##???}"
        echo "Right"
        ;;
      $'\x1B\x4F\x48'*) # Home
        KEYS="${KEYS##???}"
        echo "Home"
        ;;
      $'\x1B\x5B\x31\x7E'*) # Home (Numpad)
        KEYS="${KEYS##????}"
        echo "Home (Numpad)"
        ;;
      $'\x1B\x4F\x46'*) # End
        KEYS="${KEYS##???}"
        echo "End"
        ;;
      $'\x1B\x5B\x34\x7E'*) # End (Numpad)
        KEYS="${KEYS##????}"
        echo "End (Numpad)"
        ;;
      $'\x1B\x5B\x45'*) # 5 (Numpad)
        KEYS="${KEYS#???}"
        echo "Center (Numpad)"
        ;;
      $'\x1B\x5B\x35\x7e'*) # PageUp
        KEYS="${KEYS##????}"
        echo "PageUp"
        ;;
      $'\x1B\x5B\x36\x7e'*) # PageDown
        KEYS="${KEYS##????}"
        echo "PageDown"
        ;;
      $'\x1B\x5B\x32\x7e'*) # Insert
        KEYS="${KEYS##????}"
        echo "Insert"
        ;;
      $'\x1B\x5B\x33\x7e'*) # Delete
        KEYS="${KEYS##????}"
        echo "Delete"
        ;;
      $'\n'*|$'\r'*) # Enter/Return
        KEYS="${KEYS##?}"
        echo "Enter or Return"
        ;;
      $'\t'*) # Tab
        KEYS="${KEYS##?}"
        echo "Tab"
        ;;
      $'\x1B') # Esc (without anything following!)
        KEYS="${KEYS##?}"
        echo "Esc - Quitting"
        exit 0
        ;;
      $'\x1B'*) # Unknown escape sequences
        echo -n "Unknown escape sequence (${#KEYS} chars): \$'"
        echo -n "$KEYS" | od --width=256 -t x1 | sed -e '2,99 d; s|^[0-9A-Fa-f]* ||; s| |\\x|g; s|$|'"'|"
        KEYS=""
        ;;
      [$'\x01'-$'\x1F'$'\x7F']*) # Consume control characters
        KEYS="${KEYS##?}"
        ;;
      *) # Printable characters.
        KEY="${KEYS:0:1}"
        KEYS="${KEYS#?}"
        echo "'$KEY'"
        ;;
    esac
done

trap "stty $(stty -g)" EXIT
stty -echo -icanon time 2 || exit $?

    # Read more input from keyboard when necessary.
    while read -t 0 ; do
        read -s -r -d "" -N 1 -t 0.2 CHAR && KEYS="$KEYS$CHAR" || break
    done

// makefile-creator, generates editable, makefile for single binary 
// executables written in C or C++.

#include <stdio.h>    // printf, sprintf, etc.
#include <stdlib.h>   // exit()
#include <unistd.h>   // tons of stuff
#include <malloc.h>   // memory allocation
#include <string.h>   // strings and block comparisons and moves

#include "slist.h"

void dbg(){}          // a breakpoint for kdbg.exec

// returns error code
int usage(int errcode);

// these return 0 on success else error
int create_dirs(const char* srcdir, const char* objdir, const char* bindir);
int read_srclist(char*** psrclist, const char* srcdir);
int read_hdrlist(char*** phdrlist, const char* srcdir);
void create_objlist(char*** pobjlist, char** srclist);
int write_makefile(
  const char* bindir, const char* out_name, 
  const char* compiler_name,	
  const char* srcdir, char** srclist, char** hdrlist,
  const char* objdir, char** objlist);


const char* appname;
const char* HERE; // initial dir

int main(int argc, char** argv)
{
  dbg();
  
  int offset = 0;
  int chk;
  // TODO: handle this error flag when true
  int err = 0;
  appname = basename(argv[0]);
  HERE = getenv("PWD");
  
  const char* compiler_name;
  
  // syntax check
  if(argc < 2)
  	return usage(1);
  
  // switch check, only allows optional switch as first param
  if(argc > 2)
  {
// CORRECTED THIS -rs
//   if(strstr("++", argv[1])) 
    if(strstr(argv[1], "++"))
       compiler_name = "g++";
    else
       compiler_name = "gcc";
    offset++;
  }	
  
  // list of sources, headers and objects, names only,
  // paths will be added later to simplify string stuff
  char** srclist = slist_new();
  char** hdrlist = slist_new();
  char** objlist = slist_new();
  
  // output file name
  const char* out_name = argv[1 + offset];
  
  // other vars for the makefile: SRCDIR, OBJDIR, BINDIR
  const char* srcdir = "src";
  const char* objdir = "o";
  const char* bindir = ".";
  
  // init dirs if they don't exist yet.
  err = create_dirs(srcdir, objdir, bindir);
  
  err = read_srclist(&srclist, srcdir);
chk = slist_count(srclist);
  err = read_hdrlist(&hdrlist, srcdir);
chk = slist_count(hdrlist);
  create_objlist(&objlist, srclist);
  
  err = write_makefile(bindir, out_name, compiler_name,	srcdir, srclist, hdrlist, objdir, objlist);
  	
  return err;
}


int usage(int errcode)
{
  /* usage_str.txt converted with txt2cstr */
  const char* usage_str =
  "\n"
  "Usage: %s [c|c++] <filename>\n"
  "  where filename is the name of the output file.\n"
  "\n"
  "  Place all your sources in a directory named 'src' and choose\n"
  "  a c or c++ type of build (default = c) and your makefile will \n"
  "  be created, ready to 'make' or edit.\n"
  "\n"
  ;
  
  printf(usage_str, appname);
  return errcode;

}

// let's cheat and use a shell command for this so we don't have
// to mess with mode bits.
int create_dirs(const char* srcdir, const char* objdir, const char* bindir)
{
  int err;
  char buf[256];
  sprintf(buf, "mkdir -p %s", srcdir);
  err = system(buf);
  sprintf(buf, "mkdir -p %s", objdir);
  err |= system(buf);
  sprintf(buf, "mkdir -p %s", bindir);
  err |= system(buf);
  return err;
}

// let's cheat and use 'find' to get the file names.
int read_srclist(char*** psrclist, const char* srcdir)
{
  int err = 0;
  
  if(chdir(srcdir)) return 1;
  // find src -type f -name *.c -o -name *.cxx -o -name *.cpp 
  char syscmd[256];
  sprintf(syscmd, "find * -maxdepth 0 -type f -name '*.c' -o -name '*.cxx' -o -name '*.cpp'");
  err = slist_readPipe(psrclist, syscmd);
  chdir(HERE);
  return err;
}

int read_hdrlist(char*** phdrlist, const char* srcdir)
{
  int err = 0;
  if(chdir(srcdir)) return 1;
  // find src -type f -name *.c -o -name *.cxx -o -name *.cpp 
  char syscmd[256];
  sprintf(syscmd, "find * -maxdepth 0 -type f -name '*.h' -o -name '*.hxx' -o -name '*.hpp'");
  err = slist_readPipe(phdrlist, syscmd);
  chdir(HERE);
  return err;
}

void create_objlist(char*** pobjlist, char** srclist)
{
  int i; // loop counter
  char tmp[256]; // temp string
  char* p;       // scrath pointer
  char* filename;
  for(i = 0; i < slist_count(srclist); i++)
  {
  	filename = srclist[i];
  	// change ext from .* to .o
  	strcpy(tmp, filename);
  	p = strrchr(tmp, '.');
  	strcpy(p, ".o");
  	
  	// tmp now = objdir/filename.o
  	slist_append(pobjlist, tmp);
  }	
}

void write_makehdr(FILE* fp) {
fprintf(fp, 
"## Makefile created with 'makefile-creator'\n\n");
}

void assign_outname(FILE* fp, const char* outname) {
fprintf(fp, 
"## The outputf file name not including path\n"
"OUTNAME = %s\n\n", outname);
}

void assign_dirs(FILE* fp, const char* bindir, const char* srcdir, const char* objdir) {
fprintf(fp, 
"## The directories for sources, (temp) objects, and binary output(s)\n"
"BINDIR = %s\n"
"SRCDIR = %s\n"
"OBJDIR = %s\n\n", bindir, srcdir, objdir);
}


void assign_compiler(FILE* fp, const char* compiler_name) {
fprintf(fp, 
"## What COMPILE should do.\n"
"COMPILE = %s -m32 -c -o\n"
"CFLAGS = # -O2 or -g3\n"
"INCLUDE = -I/usr/include -I./$(SRCDIR)\n\n", compiler_name);
}

// compiler name = linker name here.
void assign_linker(FILE* fp, const char* linker_name) {
fprintf(fp,
"## What LINK should do.\n"
"LINK = %s -m32 -o\n"
"LDFLAGS = # -lc\n"
"LIB = -L/usr/lib\n\n", linker_name);
}

void write_list(FILE* fp, const char* dir, char** list) {
  int i;
  for(i = 0; i < slist_count(list); i++) {
  	fprintf(fp, "  %s/%s \\\n", dir, list[i]);
  }
}

void assign_lists(FILE* fp, const char* srcdir, char** srclist, char** hdrlist, const char* objdir, char** objlist) {
fprintf(fp, 
"## The full path to the output file\n"
"MAIN = $(BINDIR)/$(OUTNAME)\n"
"\n"
"# MODIFY BELOW THIS LINE WITH GREAT CARE!\n"
"# ---------------------------------------\n"
"\n");

  const char* endlist = "  #############\n\n";
  
  fprintf(fp,"SRC = \\\n");
  write_list(fp, srcdir, srclist);
  fprintf(fp, endlist);	
  
  fprintf(fp,"HDR = \\\n");
  write_list(fp, srcdir, hdrlist);
  fprintf(fp, endlist);	
  
  fprintf(fp,"OBJ = \\\n");
  write_list(fp, objdir, objlist);
  fprintf(fp, endlist);
}

void write_rules(FILE* fp, char** srclist, char** objlist)
{
int i; // loop counter
fprintf(fp, "################################## Rules Section\n");
fprintf(fp, "\n");
fprintf(fp, "all: $(MAIN) $(HDR) $(OBJ) $(SRC)\n");
fprintf(fp, "\n");
fprintf(fp, "$(MAIN): $(OBJ) $(HDR) $(SRC)\n");
fprintf(fp, "\t@echo\n");
fprintf(fp, "\t@echo \"Linking $(OUTNAME)\"\n");
fprintf(fp, "\t$(LINK) $(MAIN) $(OBJ) $(LDFLAGS) $(LIB)\n");
fprintf(fp, "\t$(POST)\n");
fprintf(fp, "\n");

  for(i = 0; i < slist_count(srclist); i++)
  {
  fprintf(fp, "$(OBJDIR)/%s: $(SRCDIR)/%s $(HDR)\n", objlist[i], srclist[i]);
  fprintf(fp, "\t@echo\n");
  fprintf(fp, "\t@echo \"Compiling %s\"\n", objlist[i]);

  // fprintf(fp, "\t$(COMPILE) $(OBJDIR)/%s $(SRCDIR)/%s $(CFLAGS) $(INCLUDE)\n",	objlist[i], srclist[i]);
  // Added an extra newline at the end of this line -rs
  fprintf(fp, "\t$(COMPILE) $(OBJDIR)/%s $(SRCDIR)/%s $(CFLAGS) $(INCLUDE)\n\n",	objlist[i], srclist[i]);

  }
}

void write_userdef(FILE* fp)
{
fprintf(fp, "################################## User Defined\n");
fprintf(fp, "\n");
fprintf(fp, "clean:\n");
fprintf(fp, "\t@rm -f $(MAIN)\n");
fprintf(fp, "\t@rm -f $(OBJ)\n");
fprintf(fp, "\t@rm -f *~ */*~ */*/*~ */*/*/*~\n");
}

int write_makefile(
const char* bindir, const char* out_name, 
const char* compiler_name,	
const char* srcdir, char** srclist, char** hdrlist,
const char* objdir, char** objlist)
{
  FILE* fp = fopen("Makefile", "r");
	if(fp) { system("cp -f Makefile Makefile-backup"); fclose(fp); }
	fp = fopen("Makefile", "w");
  if(! fp) {
		fprintf(stderr, "Can't create Makefile\n");
  	return 1;
  }
  write_makehdr(fp);
  assign_outname(fp, out_name);
  assign_dirs(fp, bindir, srcdir, objdir);
  assign_compiler(fp, compiler_name);
  assign_linker(fp, compiler_name);
  assign_lists(fp, srcdir, srclist, hdrlist, objdir, objlist);
  write_rules(fp, srclist, objlist);	
  write_userdef(fp);
  fclose(fp);
}

mkdir -p o
g++ -c src/makefile-creator.cpp -o o/makefile-creator.o
g++ -c src/slist.cpp -o o/slist.o
g++ o/* -o makefile-creator

$> make
make: *** No targets.  Stop.

$> make
make: Nothing to be done for `all'.

string = Im   doing something  .

all: target

target:
	echo $(string)

$> make
echo Im   doing something  .
Im doing something .

string = "I'm doing something!"

all: target

target: dep1 dep2 dep3
	echo $(string)
	@echo "That's all I can tell you right now."

dep1:
	@echo "My name is 'echo'"

dep2:
	@printf "What are you doing? "

dep3:
	@echo "if you don't mind my asking."
	@echo

string = "I'm doing something!"

all: target

target: dep3
	echo $(string)
	@echo "That's all I can tell you right now."

# and let's mix 'em up a bit...

dep1:
	@echo "My name is 'echo'"

dep3:dep2
	@echo "if you don't mind my asking."
	@echo

dep2:dep1
	@printf "What are you doing? "

string = "I'm doing something!"

all: temp.txt

temp.txt: target
	@echo "temp.txt has been created."

target: dep3
	echo $(string)                       >> temp.txt
	@echo "That's all I can tell you right now." >> temp.txt

# and let's mix 'em up a bit...

dep1:
	@echo "My name is 'echo'" >> temp.txt

dep3:dep2
	@echo "if you don't mind my asking."  >> temp.txt
	@echo                                 >> temp.txt

dep2:dep1
	@printf "What are you doing? "  >> temp.txt

# this tag/target will run when we type 'make clean'
clean:
	@rm temp.txt

string = "I'm doing something!"

all: temp.txt
	@echo "temp.txt has been created."

temp.txt:
	@echo "My name is 'echo'" >> temp.txt
	@printf "What are you doing? "  >> temp.txt
	@echo "if you don't mind my asking."  >> temp.txt
	@echo                                 >> temp.txt
	@echo $(string)                       >> temp.txt
	@echo "That's all I can tell you right now." >> temp.txt

clean:
	@rm temp.txt

# type 'source mbrfun.sub' to load
function mbr_backup # mbr_file
{
  dd of=$1 if=/dev/sda count=1
}

function mbr_write # mbr_file
{
  dd if=$1 of=/dev/sda count=1
}

function mbr_help
{
echo "
  Commands:
    mbr_backup # to_filename
    mbr_write  # from_filename
 "
}

mbr_help # show now

#!/bin/sh
# creates a new exec file named $1.exec that does $2

name_exec="$1.exec"
cd_here='cd `dirname "$0"`'
shift
cmd="$@"

echo '#!/bin/sh' > $name_exec
echo "$cd_here" >> $name_exec
echo "printf \"\" >.msg" >> $name_exec
echo "$cmd 2>>.msg" >> $name_exec
echo "echo 'done.' >> .msg" >> $name_exec
echo "kdialog --msgbox \"\$(<.msg)\"" >> $name_exec
echo "rm -f .msg" >> $name_exec

chmod +x $name_exec

new.exec test

#!/bin/sh
msg="
  PWD=  $PWD
  PATH= $PATH
  FILE= $1
  LD_LIBRARY_PATH = $LD_LIBRARY_PATH
 "
kdialog -msgbox "$msg"

# Add code as req'd here, for example,
cd `dirname "$0"` # to go to the directory where the file was clicked on
"$1" 
# the line above runs the program. spaces in path = OK.

HOME/.local/share/applications

browse ~/.local/share/applications

application/x-shellscript
application/x-executable

Mouse click
ENTER key

binaries | open with
  click [unknown]
  ENTER [shell-exec]

Repeat the test with test.exec (dolphin)
  click [unknown]
  ENTER [shell-exec]

Repeat the test with test.exec (konqueror) 
  click [unknown]
  ENTER [kwrite]

Repeat the test with test.sh (dolphin)
  click [unknown]
  ENTER [shell-exec]

Repeat the test with test.sh (konqueror)
  click [unknown]
  ENTER [kwrite]

        |  clicked  |   ENTER key (dolphin/konqueror)
          ----------------------
*.exec  |  GHOSTS?  |   shell-exec / kwrite
*.sh    |  GHOSTS?  |   shell-exec / kwrite
binary  |  GHOSTS?  |   shell-exec / (untested*)

xdg-mime query filetype <filename>

[Added Associations]
application/x-executable=shell-exec.desktop;

[Desktop Entry]
Exec=shell-exec
MimeType=application/x-executable;
Name=shell-exec
NoDisplay=true
Type=Application

[list of 45 unique deps deleted -rs]
---------------------------------------------------
binaries found : 125
ldd pipe errors: 0
external deps  : 45
---------------------------------------------------
real    0m1.667s -- less than two seconds (cmd: 'time find-deps /bin -i')
user    0m0.727s
sys     0m0.778s

HOME
 \-- bin
      \-- src
           \-- find-deps-1.0 [everything goes here]

// initial app created
#define VERSION "1.0"

/* usage.txt converted with txt2cstr */
const char* usage_str =
    "\n"
    "Usage: find-deps <branch>\n"
    "\n"
    "  Primary usage is for discovering files needed by a binary package before\n"
    "  installation/building, etc.\n"
    "\n"
    "  Prints out a list of all libs used by executable files and libs \n"
    "  found in the directory <branch> (recursive). \n"
    "\n"
    "  Does not list files that are resolved by other files in the same \n"
    "  branch.\n"
    "\n"
    "  Does not look in any other branches for resolvers.\n"
    "\n"
    "Switches:\n"
    "  -i | --info         display info about files found\n"
    "  -v | --version      show version\n"
    "\n"
    "Notes: \n"
    "\n"
    "  1. Needs linux tools 'find' and 'ldd' to run.\n"
    "\n"
    "  2. If a symlink points to a non-existent file (as encountered in \n"
    "  development packages) this will be still be counted as a self-resolved \n"
    "  dependency.\n"
    "\n"
    "  3. The error message \"No elf binaries found\" sent to stderr could mean\n"
    "  that there really aren't any or just that the path doesn't exist.\n"
    "\n"
    "  4. May not work for system dirs (e.g. /usr/bin, /usr/lib, /lib) due to \n"
    "  ldd quirks but we can get 'info' on the number of elf files.\n"
    "\n"
    ;

// find-deps.cpp

// shotgun load some commonly used headers
#include <stdio.h>    // printf, sprintf, etc.
#include <stdlib.h>   // exit()
#include <unistd.h>   // tons of stuff
#include <malloc.h>   // memory allocation
#include <string.h>   // strings and block comparisons and moves

// our own includes
#include "slist.h"
#include "version.h"

void dbg(){}          // a breakpoint for kdbg/gdb

//////////////////////////////////////////////////////
// prototypes section

// saved current directory path
extern char* HERE;

// true if we want to know how many files were processed
extern int infoflg;

// number of pipe to ldd errors
extern int ldderrs;

// name of currently running app
extern char* appname;

// reorder args so switches precede args and return
// # of switches.
int reorder_args(int argc, char** argv);

// find and store names of elf executables in elflist,
// returns 0 on success
int find_elf(char*** pelflist, const char* prefix);

// find and store dependency libs in depslist, not including files
// in elflist, returns 0 on success
int find_deps(char*** depslist, const char* prefix, char** elflist);

// process recognized switches and return errcode if bad switch
// value.
int handle_switches(int n, char** argv);

// usage note
int usage(int errcode);

//////////////////////////////////////////////////////
// the program

// saved current directory path
char* HERE;

// true if we want to know how many files were processed
int infoflg = 0;

// number of pipe to ldd errors
int ldderrs = 0;

// name of currently running app
char* appname;

int main(int argc, char** argv)
{
  dbg();
  
  appname = basename(argv[0]);
  
  int err = 0;
  char** elflist = slist_new();
  char** depslist = slist_new();  
  int offset = 0; // increases for each commandline switch
  
  // syntax checks, should return usage(1) if argc < 2, but... whatever :-)
  if((argc < 2) || (strcmp(argv[1], "--help") == 0))
    return usage(0);
      
  // switches
  offset = reorder_args(argc, argv);
  err = handle_switches(offset, argv);
  if(err)
    return err;
  
  // setup
  const char* prefix = argv[1 + offset];
  HERE = getenv("PWD");
  
  // get list of all elf executables in prefix dir
  err = find_elf(&elflist, prefix);
  
  int num_elf = slist_count(elflist);

  if(num_elf == 0)
  {
    fprintf(stderr, "No elf binaries found.\n");
    return 1;
  }
  
  // get list of deps in all elf files that are not in the
  // list already in the prefix dir
  err = find_deps(&depslist, prefix, elflist);
  
  int num_deps = slist_count(depslist);

  for(int i = 0; i < slist_count(depslist); i++)
    printf("%s\n", depslist[i]);
  
  if(infoflg)
  {
    const char* hline =
       "---------------------------------------------------";
    printf("%s\n", hline);
    printf("binaries found : %d\n"
           "ldd pipe errors: %d\n"
           "external deps  : %d\n",
           num_elf, ldderrs, num_deps);
    printf("%s\n", hline);
  }
  
  // cleanup and return
  slist_delete(depslist);
  slist_delete(elflist);
  return 0;
}

//////////////////////////////////////////////////////
// the library of functions and various utils

// utils - misc

// returns true (1) if filename is an elf file
int is_elf(const char* fname)
{
  FILE* fp = fopen(fname, "r");
  if(! fp) return 0; // error, file not found
  
  // read the first few bytes of the file and look for the
  // signature of a valid elf binary.
  char buf[8] = {0};
  fread(buf, 1, 4, fp);
  if(memcmp(buf, "\177ELF", 4) == 0)
    return 1; // true
  return 0;   // false
}

int reorder_args(int argc, char** argv)
{
  // make literal copy of argv list in temporary list
  char** tmp_args = (char**)malloc(argc * sizeof(char**));
  memcpy(tmp_args, argv, argc * sizeof(char**));
  
  int cnt = 1; // current copy back number, app path is at [0] (no change)
  int nswitches = 0; // the value to return
  
  // copy switches (anything starting with '-') back first
  for(int i = 1; i < argc; i++)
    if(tmp_args[i][0] == '-')
      argv[cnt++] = tmp_args[i];
  
  nswitches = cnt - 1; // number of actual switches
  
  // copy non-switches back next
  for(int i = 1; i < argc; i++)
    if(tmp_args[i][0] != '-')
      argv[cnt++] = tmp_args[i];
  
  free(tmp_args);
  return nswitches;
}

/////////////////////////////////////////////////////////

// find and store names of elf executables in elflist,
// returns 0 on success
int find_elf(char*** pelflist, const char* prefix)
{  
  // init the flag and the list which is an array of 
  // pointers terminated by a zero and save current
  // directory so we can always return to it.
  int err = 0;
  char pipcmd[512];
  char** elflist = *pelflist; /// remove after test
  char** tmp = slist_new();

  // Create a non-looping do-while block we can leave 
  // at the first error.  Functionally equivalent to a 
  // string of ORs using err as the flag.
  do
  {  
    char pipecmd[512];
    err = chdir(prefix);
    if(err) break;
  
    // get complete list of all executables, then
    // remove those not elf type.
    sprintf(pipecmd, "find * -executable");
    err = slist_readPipe(&elflist, pipecmd);
    if(err)
    {
      slist_clear(elflist);
      break;
    }
    
    // remove non-elf files
    for(int i = 0; i < slist_count(elflist); i++)
    {
      if(is_elf(elflist[i]))
        slist_append(&tmp, elflist[i]);
    }
  }while(0);
  if(err) return err;
  
  // elflist = tmp;
  slist_delete(elflist);
  //elflist = tmp->list();
  elflist = tmp;
  *pelflist = elflist;
  // delete tmp;
  chdir(HERE);
  return 0;
}

void elfpaths_only(char*** plist)
{
  int state = 0;
  char** list = *plist;
  char** tmp = slist_new();
  
  for(int i = 0; i < slist_count(list); i++)
  {
    // THANK YOU :-) to the svanah non-gnu BNF project for this trick
    char buf[256];
    sprintf(buf, list[i]);
    char* ip = buf, *op = buf;
    do
    {
      // skip whitespaces
      while(*ip <= ' ')
        ip++;
      
      // don't want blank lines
      if(!*ip)
        break;
      
      // want lines starting with slash
      if(*ip == '/')
        break;
      
      // don't want lines not pointing to lib path
      ip = strstr(ip, " => ");
      if(!ip)
        break;
      
      ip += 4; // move to file path, should start with '/'
      
      // don't want lines not having a lib path
      if(*ip != '/')
        break;
      
      // MATCHED - now copy to first non text and terminate string
      while(*ip > ' ')
        *op++ = *ip++;
      *op = 0;
      
      state = 1; // signale that we got one
    }while(0);
      
    if(state)
      slist_append(&tmp, buf);
  }
  
  // save new result and return
  slist_delete(list);
  *plist = tmp;
}

// find and store dependency libs in depslist, not including files
// in elflist, returns 0 on success
int find_deps(char*** pdepslist, const char* prefix, char** elflist)
{
  // init
  char** depslist = *pdepslist;
  int err = 0;
  char pipecmd[512];
  
  err = chdir(prefix);
  if(err) return 1;
  
  int len = slist_count(elflist);
  for(int i = 0; i < len; i++)
  {
    // get list of ldd libs loaded by each elf file and add
    // to the depslist, temporarily before removing dups.
    
    char** sublist = slist_new();
    
    sprintf(pipecmd, "/usr/bin/ldd %s", elflist[i]);
    err = slist_readPipe(&sublist, pipecmd);
    
    // count ldd errors
    if(err)
      ldderrs++;
    
    elfpaths_only(&sublist);
    
    // "you will be assimilated" said depslist to sublist....
    slist_addList(&depslist, sublist);
    slist_delete(sublist);
  }while(0);
  
  int ip;
  int op;
  
  // remove duplicates if any items to copy
  ip = 0;  
  for(ip = 0; ip < slist_count(depslist); ip++)
  {
    op = ip + 1;
    while(op < slist_count(depslist))
    {
      // shrink list or advance pointer...
      if(strcmp(depslist[op], depslist[ip]) == 0)
        slist_remove(&depslist, op);
      else
        op++;
    }
  }
  
  // remove self-resolved and hope the paths are right 
  // after installation because we won't (can't) check them at
  // this point without setting LD_LIBRARY_PATH and that can 
  // be as error prone as this, so... here we go.  If it 
  // exists at all in our branch, we count is as 'resolved'.
  for(int elf = 0; elf < slist_count(elflist); elf++)
  {
    char* elffile = basename(elflist[elf]);
    for(int dep = 0; dep < slist_count(depslist); dep++)
    {
      char* depfile = basename(depslist[dep]);
      if(strcmp(elffile, depfile) == 0)
        slist_remove(&depslist, dep);
    }
  }

  *pdepslist = depslist;
  chdir(HERE);
  return 0;
}

int usage(int errcode)
{
#include "usage_str.dat"
  printf(usage_str); 
  return errcode;
}

// process recognized switches and return errcode if bad switch
// value.
int handle_switches(int n, char** argv)
{
  n++; // don't count argv[0] (app path)
  
  // we already know the first char is a '-' so we look for
  // substrings common to both long and short switches.
  
  for(int i = 1; i < n; i++)
  {
    // -v or --version
    if(strstr(argv[i], "-v"))
    {
      printf("%s version %s\n", appname, VERSION);
      exit(0);
    }
    
    // -i or --info
    else if(strstr(argv[i], "-i"))
      infoflg = 1;
    
    else
    {
      fprintf(stderr, "Unrecognized switch %s\n", argv[i]);
      return 1; // not a valid switch
    }
  }
  return 0; // ok
}

// if you must, here's a way to do this without linking explicitly. :-)
// #include "slist.cpp" // uncomment this line.
// COMPILE: g++ find-deps.cpp -o find-deps

#include "slist.cpp"

  // save the result and return ok
  free(buf);  // ADD THIS LINE
  *plist = list;
  return 0;
}

// slist.h

#ifndef SLIST_H
#define SLIST_H

// TODO:
// slist_insert(char*** plist, s, idx)   -- insert new item at idx
// slist_moveList(plist1, idx, plist2, delete_flg)  -- overwrite and append,
//                                                 -- [empty or delete list2]
// slist_trim(plist, idx)                -- remove items from idx to end
// slist_shift(plist, n)                 -- remove first n items from list

// returns an initialized pointer to a list base
char** slist_new();

// removes item and deletes the base
void slist_delete(char** list);

// returns number of items in the list
int slist_count(char** list);

// removes items, does not resize or delete the base
void slist_clear(char** list);

// adds a new items at the end of the list
void slist_append(char*** plist, const char* s);

// removes (and frees) item at idx. Does not resize the list
void slist_remove(char*** plist, int idx);

// adds list list2 to list1, does not delete list that's added
void slist_addList(char*** plist1, char** list2);

// remove one trailing newline char from a string
// static void trim_newline(char* buf);

// Loads list with strings from a piped command,
// returns 0 on success
int slist_readPipe(char*** plist, const char* pipecmd);

// writes list through pipe, returns 0 on success.
int slist_writePipe(char*** list, const char* syscmd);

#endif // SLIST_H

// slist.cpp -- lists of strings in the format of an args list, 0 terminated.

#include <malloc.h> // malloc and free
#include <string.h> // str*() funcs

#include "slist.h"

// returns an initialized pointer to a list base
char** slist_new()
{
  char** p = (char**)malloc(sizeof(char**));
  *p = 0;
  return p;
}


// removes item and deletes the base
void slist_delete(char** list)
{
  int i = 0;
  while(list[i])
    free(list[i++]);
  free(list);
}

// returns number of items in the list
int slist_count(char** list)
{
  int i = 0;
  while(list[i])
    i++;
  return i;
}

// removes items, does not resize or delete the base
void slist_clear(char** list)
{
  int i = 0;
  for(int i =  0; list[i] != 0; i++)
  {
    free(list[i]);
    list[i] = 0;
  }
}

// adds a new items at the end of the list
void slist_append(char*** plist, const char* s)
{
  int count;
  char** list = *plist;
  for(count = 0; list[count]; count++)
    ; // noop
  list = (char**)realloc(list, sizeof(char**) * (count + 2));
  list[count] = strdup(s);
  list[count + 1] = 0;
  *plist = list;
}

// removes (and frees) item at idx. Does not resize the list
void slist_remove(char*** plist, int idx)
{
  char** list = *plist;
  int len = slist_count(list);
  if((idx < 0) || (idx > len))
    return;
  free(list[idx]);
  for(int i = idx; i < len; i++)
    list[i] = list[i+1];
  // *plist = list; -- already set since no resizing is done
}


// adds list list2 to list1, does not delete list that's added
void slist_addList(char*** plist1, char** list2)
{
  int len = slist_count(list2);
  for(int i = 0; i < len; i++)
    slist_append(plist1, list2[i]);
}


// remove one trailing newline char from a string
static void trim_newline(char* buf)
{
  char* p = buf + strlen(buf) -1;
  if(*p == '\n')
    *p = 0;
}

// Loads list with strings from a piped command,
// returns 0 on success
int slist_readPipe(char*** plist, const char* pipecmd)
{
  size_t bufsize = 4096;
  char* buf = (char*) malloc(bufsize);
  char** list = *plist;
  FILE* fp = popen(pipecmd, "r");
  if(! fp) return 1;
  while(! feof(fp))
  {
    *buf = 0;
    getline(&buf, &bufsize, fp);
    
    // done if nothing is read
    if(! *buf)
      break;
    
    trim_newline(buf);
    slist_append(&list, buf);
  }
  fclose(fp);
  
  // save the result and return ok
  *plist = list;
  free(buf); // ADDED -rs
  return 0;
}

// writes list through pipe, returns 0 on success.
int slist_writePipe(char*** plist, const char* pipecmd)
{
  char** list = *plist;
  FILE* fp = popen(pipecmd, "w");
  if(! fp) return 1;
  for(int i = 0; i < slist_count(list); i++)
  {
    char* line = list[i]; // to see in debugger
    fprintf(fp, "%s\n", line);    
  }
  fclose(fp);
  return 0;
}

// some commonly used c headers, no harm in overkill
#include <stdio.h>    // printf, sprintf, etc.
#include <stdlib.h>   // exit()
#include <unistd.h>   // tons of stuff
#include <malloc.h>   // memory allocation
#include <string.h>   // strings and block comparisons and moves

#include "slist.h"    // all we need is the header

void dbg(){} // place a breakpoint here that won't move even if main() does.

int main(int argc, char** argv)
{
  dbg(); // best if viewed with kdbg.
  
  // add test code here
  
  return 0; // no errors
}

COMPILE() # basename
{
  g++ -c $CFLAGS $1.cpp -o $1.o
}

LINK()
{
  g++ $LDFLAGS $OBJ -o $1
}

COMPILE slist

COMPILE main

OBJ=`ls *.o` # Think about this.  :-)  Automatic object listing.
echo $OBJ # and verify that main.o and slist.o are both compiled.

LINK output

CFLAGS="-g3"

hlp gcc

// main.c
// COMPILE: gcc main.c -o main --save-temps
// take a look at the C asm output file, 'main.s' afterwar

// 64 bit asm keeps part of the stack in registers in C, so let's
// keep this simple and compilt it for 32 bit intel x86.

#include <stdio.h>

// We can use C macros to hide ugly details such as giving 
// the function a global name we can use to call it.  We'll
// use backslashes to span lines to make it more readable.

#define LABEL(name) \
    ".text;\n" \
    ".globl "#name";\n" \
    ".type " #name", @function;\n" \
    ""#name":"

#define FUNCTION(name) \
    asm( \
    ".text;\n" \
    ".align 4\n" \
    LABEL(name) \
    );

// returns char* as a long
long test_readvar(char* s);

// sets [addr] = s
void test_writevar(char** addr, const char* s);

// functionally identical to this
void c_writevar(char** addr, char* s)
{
  *addr = s;
}

char* watch; // copy a value here to see it in a debugger

// Let's create a stretch of throwaway code in C in which we 
// can compile some straight assembler routines.  This basically
// switches the assembler to compile in the .text section.

void code_section()
{
  // We are now in a code block created by C, i.e., the .text
  // section, so the following FUNCTION will be somewhat redundant
  // but certainly easier to read than the gory details of the full
  // declaration.
  
  // C pushes the params on the stack, right to left.  This is 
  // straight asm code so there is no frame pointer, esp points
  // to the return address, esp+4 points to first param in param
  // list.
  FUNCTION(test_readvar) // return contents of value on the stack
  asm(
      // This is the first opcode that executes in the call.
      "mov 4(%esp), %eax;"
      
      // Note that we don't need newlines after the semicolons
      // here, but if you have a syntax error there will be 
      // few usable clues about where it occurred.
      
      // And this is the last byte to execute in this code.
      "ret;"
  );
  // end function
  // Now let's try  intel syntax
  FUNCTION(test_writevar) // (var, val)
  asm(
      ".intel_syntax noprefix;\n"
      
      // C let's us play with eax and edx, but others need to be 
      // saved and restored.
      "MOV    EAX, DWORD PTR [ESP+4];\n"  // var
      "MOV    EDX, DWORD PTR [ESP+8];\n"  // val
      "MOV    DWORD PTR [EAX], EDX;\n"    // [var] = val
      "RET;\n"
      
      // if we don't switch back, C will choke on intel syntax
      ".att_syntax\n"
     );
}

void thats_all_folks() {printf("That's All Folks!\n\n");}

int main()
{
  char*x = "testing";
  // first test
  long addr = test_readvar(x);
  printf("readvar -> Addr: 0x%X\tValue: %s\n", addr, x);
  
  // second test, and also rerun first routine for printout
  test_writevar(&x, "finished");
  
  addr = test_readvar(x); // to get new value
  printf("readvar -> Addr: 0x%X\tValue: %s\n", addr, x);
  
  // and we can inline asm with C as well
  asm( "call thats_all_folks;");
  return 0;
}

#define __stdcall __attribute__((__stdcall__))
#define _stdcall __attribute__((__stdcall__))
#define stdcall __attribute__((__stdcall__))

objdump -d main -M intel_syntax

tofile objdump -d -M intel_syntax main

08048454 <c_writevar>:
 8048454: 8b 44 24 04           mov    eax,DWORD PTR [esp+0x4]
 8048458: 8b 54 24 08           mov    edx,DWORD PTR [esp+0x8]
 804845c: 89 10                 mov    DWORD PTR [eax],edx
 804845e: c3                    ret    

08048468 <test_writevar>:
 8048468: 8b 44 24 04           mov    eax,DWORD PTR [esp+0x4]
 804846c: 8b 54 24 08           mov    edx,DWORD PTR [esp+0x8]
 8048470: 89 10                 mov    DWORD PTR [eax],edx
 8048472: c3                    ret

char buf[4];                // a place to hold the file data
FILE* fp;                   // a file pointer
fp = fopen(argv[1], "r");   // open first arg for reading.
fread(buf, 1, 4, fp);       // datasize = byte, get 4 of 'em
fclose(fp);                 // done with the file
dump(buf, 4);               // print it out

// file-sig.c
#include <stdio.h>
#include <string.h>
#include <malloc.h>
 
int main(int argc, char** argv)
{
  char buf[4];                // a place to hold the file data
  FILE* fp;                   // a file pointer
  fp = fopen(argv[1], "r");   // open first arg for reading.
  fread(buf, 1, 4, fp);       // datasize = byte, get 4 of 'em
  fclose(fp);                 // done with the file
//  dump(buf, 4);
  // print it out
  int i;
  for(i = 0; i < 4; i++)
    if(isprint(buf[i])) printf("%c", buf[i]);
    else printf(".");
  return 0;
}

$> file-sig file-sig
.ELF

#!/bin/sh
# This prints out 4 bytes of a file sig

# write the C file
cat << _EOF > file-sig.c
[COPY AND PASTE THE C FILE VERBATIM HERE]
_EOF

# compile it.
gcc file-sig.c -o file-sig

# run it with a valid input param so it doesn't crash.
# we know file-sig will exist so let's do that again.
file-sig file-sig

echo " <- The ELF signature from an executable binary.
  ---------------------------------------------
  Eh?  Eh?? Well?  What do you think?
  Godzilla meets Frankenstein?  Kinda fun, no?.  :-)
 "

# cleanup... Nah...  Let's leave the files hanging around
# this time.

$> autobake new c-32            # creates an intermediate makefile template, 32 bits.
$> autobake edit                # changed the name of the output program from "main" to
$> autobake create main         # write a simple main program for starters.
File extension for file-sig.<ext> ('c' or 'cpp'): c     
                                # I entered 'c' above.
$> autobake create dirs         # create default source folder and place to put object files
$> autobake create ide          # create the clickable kdevelop3 launcher
$> autobake bake                # and finally generating the makefile from the sources

#rpm -qa | grep kernel

#rpm -ivh /yum/kernel-2.6.18-8.el5.i686.rpm

#vi /boot/grub/grub.conf
default=1
timeout=5
splashimage=(hd0,0)/boot/grub/splash.xpm.gz
hiddenmenu
title Red Hat Enterprise Linux Server (2.6.18-8.el5xen)
        root (hd0,0)
        kernel /boot/xen.gz-2.6.18-8.el5
        module /boot/vmlinuz-2.6.18-8.el5xen ro root=LABEL=/ rhgb quiet
        module /boot/initrd-2.6.18-8.el5xen.img
title Red Hat Enterprise Linux Server (2.6.18-8.el5)
        root (hd0,0)
        kernel /boot/.gz-2.6.18-8.el5
        module /boot/vmlinuz-2.6.18-8.el5 ro root=LABEL=/ rhgb quiet
        module /boot/initrd-2.6.18-8.el5.img

default=1 ---> default=0

#rpm -e kernel-2.x.x.xel5.rpm

source rpm.sub

# type 'source rpm.sub' to load

_rpm_src_extract_one() # rpmFile [dir]
{
    local rpmdir=`echo "$1" | sed -r 's|\.rpm$||'`
    local destdir=$2
    if [ "$destdir" = "" ];then
        destdir="."
    fi
    mkdir -p "$destdir/$rpmdir" >/dev/null 2>&1
    rpm2cpio "$1" | (cd $destdir/$rpmdir; cpio -i --make-directories )
    local scriptname=`echo $1 | sed 's|\.rpm|\.scripts|'`
# echo "$destdir/$rpmdir/$scriptname"; read key
    rpm -qp --scripts "$1" > $destdir/$scriptname 2>/dev/null
}


rpm.src_extract() # rpmfile [dir]
{
  local dir="."
    if [ "$1" = "-d" ]; then
        dir=$2
        shift 2
    fi
    mkdir -p "$dir" >/dev/null 2>&1
    
    for file in $@
    do
        _rpm_src_extract_one "$file" $dir
    done
    
}

rpm.help()
{
  echo "
  commands:
    help              -- this quick ref
    rpm.src_extract   -- file1 [file2 ...] extract rpm file(s) to a tree (splats ok)
  "
}

rpm.help

# Apache configuration file for Xapian Omega

<Directory /srv/httpd/htdocs/omega>
    Allow          from all
    DirectorySlash On
    Options        FollowSymlinks
    Order          Deny,Allow

    RewriteEngine  On
    RewriteBase    /
    RewriteRule    ^/*$ /cgi-bin/omega/omega?DB=default&FMT=query [L]
</Directory>

<Directory /srv/httpd/cgi-bin>
    Allow          from all
    DirectorySlash On
    Options        FollowSymlinks
    Order          Deny,Allow
</Directory>

Include /etc/httpd/omega.conf

ln -s /usr/lib64/xapian-omega/bin/omega /srv/httpd/cgi-bin/omega

// main.c

/*
 * Simple memory allocation, reallocation using built-in
 * libc calls.  Based on strdup() and strcat() concepts.
 */

// use gnu99 so we can declare loop index inside for(...) block in tester
// COMPILE: gcc -std=gnu99 main.c -o main

#include <stdio.h>
#include <string.h>
#include <malloc.h>
void dbg(){}  // Try kdbg if you haven't yet.  It's dynamite.  
              // Add -g3 to the compile line if you want to enable it.

/////////////////////////////////////////////////////////////////////////
// The calling function is responsible for free-ing the memory after use.

// use xmalloc() and xrealloc() if you need safety over simplicity and speed.
void _memcat(void** dest, int* destsize, const void* src, int srcsize)
{
  int dsz = *destsize;
  *destsize += srcsize;
  *dest = realloc(*dest, dsz + srcsize);
  memcpy((char*)*dest + dsz, src, srcsize); 
  // the call at the end eliminates an unnecessary call/return pair.
  // Asm coders, see note at the bottom.
}

void _memdup(void** dest, int* destsize, const void* src, int srcsize)
{
  *dest = malloc(srcsize);
  *destsize = srcsize;
  memcpy(*dest, src, srcsize);  
}

// NOTE:
// Since C++ syntax is so strict we can create aliases that will cast the
// input params to the type needed by the functions.  This is a little risky 
// because even 'longs' can be case to char**, and crazy stuff like that so 
// consider deleting these and renaming the above without the underscore prefix 
// to renenable the more comprehensive error checks.  But this CAN be done 
// and may make breaking the ice a little more palletable for folks coming 
// from other programming languages that aren't so strict.

#define memcat(dest, destsize, src, srcsize) \
  _memcat((void**)dest, destsize, (const void*)src, srcsize)

#define memdup(dest, destsize, src, srcsize) \
  _memdup((void**)dest, destsize, (const void*)src, srcsize)


///////////////////////////////////////////////////////////////////////
// Example: 
int main(int argc, char** argv)
{
  dbg();
  const char* a = "this is a";
  const char* b = "this is b";
  
  // the memory descriptor is a base pointer and a length variable.
  // they could have been in a single object but we'll keep them 
  // separate here so the parameter lists make clear what's going on,
  // especially for those new to C/C++.
  void* pa;
  int palen;
  
  
  int paptr; // a temp for test
  
  // here we go... duplicate string a plus its terminator using memory
  // blocks instead of strings, per se.
  memdup(&pa, &palen, a, strlen(a) + 1);
  printf("memdup()\n0x%0X: %s\n", pa, pa);

  // you can lie about the buffer length to truncate the block as far
  // as the descriptor is concerned.  Don't truncate to < 0 though and
  // don't increase the length or the end of the block may be in 
  // non-existent memory.
  palen--; // remove terminator (the lie)
  
  // add a five-byte string to the memory block
  memcat(&pa, &palen, " and ", 5); 
  
  // add string b and it's null char terminator.
  memcat(&pa, &palen, b, strlen(b) + 1);
  
  // Let's have a look...
  printf("memcat()\n0x%0X: %s\n", pa, pa);

  free(pa);
  return 0;
}

stradd(char** s, const char* newstr);

#!/bin/sh

exists()  # not just a link
{
    if test -f "$1";then
    return 0    # ok
    else    return 1    # error
    fi
}

do_cleanup()
{
    for i in $1/*~
    do
        if exists "$i"; then
            echo "$i"
            rm -f "$i" >/dev/null
        fi
    done
    for i in $1/*.bak
    do
        if exists "$i"; then
            echo "$i"
            rm -f "$i" >/dev/null
        fi
    done

}


do_cleanup .
for i in * 
do 
    do_cleanup $i
done

for i in */*
do 
    do_cleanup $i
done

for i in */*/*
do 
    do_cleanup $i
done

for i in */*/*/*
do 
    do_cleanup $i
done

for i in */*/*/*/*
do 
    do_cleanup $i
done

# also remove the typical hidden backups
rm -f \.*~
rm -f */\.*~
rm -f */*/\.*~
rm -f */*/*/\.*~
rm -f */*/*/*/\.*~
rm -f */*/*/*/*/\.*~

echo
echo "done..."
echo

#!/bin/sh

browser=konqueror
opt="info"

if [ "$1" = "-m" ];then
    opt="man"
    shift
else
if [ "$1" = "-i" ];then
    opt="info"
    shift
fi ;fi

if [ "$1" = "" ];then
  #update and view ~/bin docs
  echo "
  Please wait... updating ~/bin docs
  if this isn't what you wanted to do, add the subject
  you wanted help on on the command line
  "
  
  cd ~/bin
  ./update-docs.exec 2>/dev/null # suppress errors
else
  launch "$browser '$opt:$1' >/dev/null 2>&1" 
fi

#!/bin/sh 

cd `dirname "$0"`
b=`ls new.*`

a=`printf "%s" "new.<name> creates a new set of project files.
Currently available functions are:
"`

c="$a
 
$b"

# create msgBox using gtk, qt, or kdialog if you want a nicer
# display. -rs
if ! msgBox "$c"  2>/dev/null; then
xmessage -center "$c" -default "okay"
fi

$> make

Error: Prefix not set in Makefile yet

make: *** [prefix-check] Error 1

edit Makefile

export PREFIX=$(HOME)

$> make

ERROR: Missing dat files.
Use 'make init' to create a default set

make: *** [init-check] Error 1

make init

make

Binary package, already built. Ready to install.

Precompiled binary installer/uninstaller using make.

See the WARNING at the bottom.

* The hard part:

Create a directory named TREE and load it with the files you want to make into a binary package.

Use 'make init' to make the data files.

Edit dirs.dat to remove dirs not created by the installer.  No harm 
done if you don't edit it most times, but if for example you install
into /usr/local/bin and there is nothing there when you uninstall then
the bin folder will be removed by the uninstaller and some configured
compile jobs (not this utility) don't actually recreate that folder 
first so be aware of that possibility.  

If the dirs are not empty (for any reason) they won't be uninstalled.

Make sure the prefix is set correctly for installing the files.  
That if your TREE of files is for in TREE/usr/local your prefix is 
/ (root).  If it's TREE/local, your prefix is /usr, and so forth.

The installer will attempt to back up any existing files before 
installing but you can backup manually as well. See TO BACKUP below.
If you don't want to back anything up, create an empty folder named
bak/00 and tar it up as bak/00.tar.gz.  If no files with the same
names as the newly installed ones exist, that is what the install
will do as well.

Only the first backup is set to be restored on uninstallation and 
if there is nothing in the bak/00.tar.gz file nothing will be 
restored.


* The easy part:

TO BACKUP: 
  command: make backup

  Once you have the dat files, you can make incremental backups from
  the system using 'make backup'.  If there are no files in the system
  yet, no harm done.  But if there are, the first backup may be used
  to restore the original state.

  [This is normally done automatically the first time you install in
  order to allow rolling back to the initial state.]

  Requires superuser for system backups.


TO IMPORT:
  command: make import

  If you have a file list and a list of symlinks you can put those
  lists into files.dat and links.dat and run 'make import' to get
  copies of those files from the system folders.  Do not list dirs 
  in those files or loaded dirs will get copied into the tree.

  This can be useful, for example, if you make edits in the source 
  code and and install from a configured 'make' and want to update 
  the TREE those files.  

  NOTE: if you ADD any files this way, they must be added to the dat 
  files as well or they won't get imported into the TREE.

  May superuser for system imports.


TO RESTORE:
  command: make restore

  This attempts to copy restored files (if any existed) back to their 
  original locations.  It does not remove new files, so in general,
  this would follow an 'uninstall'.

  Requires superuser for system files.
  

TO RELOCATE:  
  This is risky.

  Change PREFIX in the Makefile if you can't recompile with the new
  prefix. (and cross your fingers).  

  WARNING: Relocation WILL change the files necessary for restoring 
  so that the initial backup, if it exists, may no longer be valid.

  command: make install (after manual changes set as per above)

-------------------------------------------------------------------


Tips:

  IMPORTING CMAKE-ed INSTALLATIONS:
 
  To create a binary installer from a CMake-ed installation copy
  the files list from the cmake-generated 'install_manifest.txt' 
  into links.dat and create or empty the 'dirs.dat' and 'files.dat'
  files and run 'make import' as superuser.

  [The reason for using links.dat for the files list instead of 
  files.dat is because it will import copying attributes, including 
  symlinks whereas files.dat may cause linked files to copy over as 
  full sized files.  Other than that, the imports from both files.dat
  and links.dat are identical.  But again, do NOT include dirs in those
  files or the entire directory will be imported, even if it's loaded
  with previously existing files.]

  Then regenerate the dat files with 'make init'.

WARNING:

  In general, don't set prefix to root unless you're confident that your
  installation doesn't mess up any global configuration files.

  Keep backups.  The restore function works but if something goes wrong, 
  make sure you have a fallback you can live with.

  License = GPL.  No warrantees.  Be very careful when installing into
  root, and things should go reasonably well.  :-)

#!/bin/sh
cd `dirname "$0"`

CURDIR=`pwd`

#echo $CURDIR
#read key

NENTRIES=01

mkdir bak 2>/dev/null

if ! ls bak/* 2>/dev/null 
then
   NENTRIES=00
fi


for i in bak/*
do
    let NENTRIES=NENTRIES+1
done

#echo $NENTRIES
#read key

if [ $NENTRIES -lt 10 ]
then
echo "doing..."
    NENTRIES=0$NENTRIES
fi

NEWDIR=bak/$NENTRIES

#echo $NEWDIR
#read key

rm *~
rm */*~
rm */*/*~
rm */*/*/*~
rm */*/*/*/*~


mkdir $NEWDIR

cp -f -t $NEWDIR *
cp -r -t $NEWDIR TREE/

DIRLIST=`ls $NEWDIR`
cd bak

MSG="Creating backup '$NEWDIR.tgz'
---------------------------------------
$DIRLIST"

#if ! msgBox "$MSG";then
#    kdialog --msgbox "$MSG"
#fi
xmessage -default "okay" -center "$MSG"

# old code, feel free to fix it. -rs
pack_tgz()
{
  for i in $1
  do
    # remove if has trailing slash
    local name=`echo $i | sed 's|\/$||'` 
    if ! tar -c "$name" | gzip > $name.tgz ;then
      return 1
    fi
    if test -e $name.tgz; then
        rm -r "$name"
    else
        return 1
    fi
    exit ## only do first match if wildcard used
  done
}

pack_tgz $NENTRIES

#!/bin/sh
cd `dirname "$0"`

if [ "$1" == "initial" ];then
  if [ -e backup/01.tar.gz ];then
    echo "  
  [Initial backup (backup/01.tar.gz) exists.]
  Continuing installation, please wait...
  "
    exit
  fi
  echo "
  Creating initial backup of any files that would be overwritten by
  the installation (if any).
  "
  mk_backup working
  echo "
  Continuing installation, please wait...
  "
  exit
fi


if [ "$1" != "working" ];then
  echo "
  Only run this from the makefile as 'make <app>' where <app>
  is the name of the function minus the 'mk_' prefix

  Press ENTER to abort now.
  "
  read key; exit
  
fi

echo "Please wait..."


bp()
{
  echo $1
  read key
}

CURDIR=`pwd`

NENTRIES=01

mkdir backup 2>/dev/null

#bp 1

if ! ls backup/* >/dev/null 2>&1
then
   NENTRIES=00
fi

for i in backup/*
do
    let NENTRIES=NENTRIES+1
done

if [ $NENTRIES -lt 10 ]
then
#echo "doing..."
    NENTRIES=0$NENTRIES
fi

#bp 2

NEWDIR=backup/$NENTRIES

mkdir $NEWDIR

#bp 3

for i in $(<files.dat); do
  cp -f --parents $PREFIX/$i $NEWDIR/ 2>/dev/null
done

#bp 4

for i in $(<links.dat); do
  cp -f --no-dereference --parents $PREFIX/$i $NEWDIR/ 2>/dev/null
done

#bp 5

DIRLIST=`ls $NEWDIR`
cd backup

MSG="Creating backup '$NEWDIR.tgz'
---------------------------------------
$DIRLIST"

#if ! msgBox "$MSG";then
#    kdialog --msgbox "$MSG"
#fi
xmessage -default "okay" -center "$MSG"

#bp 6

#pack-tgz $NENTRIES
tar czf $NENTRIES.tar.gz $NENTRIES

# in case being run as su, only change owner, not group
chown -R $USER $NENTRIES 

#bp 7

rm -r $NENTRIES
cd ..
chown $USER:users -R backup

echo "Done.
 "

#!/bin/sh
cd `dirname "$0"`
HERE=$PWD

if [ "$1" != "working" ];then
  echo "
  Only run this from the makefile as 'make <app>' where <app>
  is the name of the function minus the 'mk_' prefix

  Press ENTER to abort now.
  "
  read key; exit
  
fi

if ls -d TREE/* >/dev/null 2>&1; then
  echo "
  Move or remove the existing TREE files before importing new
  ones.
  Aborting now.
  "
  exit
fi

echo "Please wait..."

bp()
{
  echo $1
  read key
}


# bp 1

mkdir -p TREE 

# only copy non-dirs
for i in $(<files.dat); do
  d=`find $i -type d`
  if [ "$d" == "" ]; then
  cp -r --parents $PREFIX/$i TREE/ >/dev/null 2>&1
  fi
done

# bp 2

# only copy non-dirs
for i in $(<links.dat); do 
  d=`find $i -type d`
  if [ "$d" == "" ]; then
  cp -r --no-dereference --parents $PREFIX/$i TREE/ >/dev/null 2>&1
  fi
done

# bp 3

for i in $(<remove.dat); do
remove_path=`dirname $i`
mkdir -p $PREFIX/$remove_path
echo "removed" > TREE/$PREFIX/$i
done

# in case being run as su, change owner, not the group

echo "Done.

  Move imported files relative to TREE=PREFIX in your Makefile
 "

#!/bin/sh
cd `dirname "$0"`
HERE=$PWD

if [ "$1" != "working" ];then
  echo "
  Only run this from the makefile as 'make <app>' where <app>
  is the name of the function minus the 'mk_' part of the name.

  Press ENTER to abort now.
  "
  read key; exit
  
fi

init_dat()
{
  local SELF_DIR=$PWD
  # running as root is ok, but not necessary here unless your
  # permissions on /usr/sbin are too restrictive

  if ! find TREE/* -type d >/dev/null 2>&1; then
    echo "
  Need at least one populated directory TREE folder in order init.
  Press ENTER to abort.
    "
    mkdir -p $SELF_DIR/TREE
    printf "" >> files.dat
    printf "" >> links.dat
    printf "" >> dirs.dat
    printf "" >> remove.dat
    chown $USER:users TREE 
    read key
    return 
  fi

  cd TREE
  
  find * -type f > ../files.dat 2>/dev/null || true
  find * -type l > ../links.dat 2>/dev/null || true

  # we want the list of dirs in reverse order so a simple rmdir
  # on empty dirs will work up the chain removing the more distant
  # ones first.
  find * -type d | sort -r > ../dirs.dat

  # in case we need to remove any old files when installing
  echo > ../remove.dat

  chown -R $USER:users ../*.dat
  cd $SELF_DIR
}

init_dat 

echo "Done.
 "

#!/bin/sh
cd `dirname "$0"`
HERE=$PWD

if [ "$1" != "working" ];then
  echo "
  Only run this from the makefile as 'make <app>' where <app>
  is the name of the function minus the 'mk_' part of the name.

  Press ENTER to abort now.
  "
  read key; exit
  
fi

if [ ! -e backup/01.tar.gz ];then
  echo "
  Can't find backup # 01.tar.gz in 'backup' folder, can't restore.
  Not restoring old files.  Press ENTER to continue  
  "
  read key
  exit
fi

echo "Please wait..."


bp()
{
  echo $1
  read key
}


cd backup
tar -xzf 01.tar.gz
if [ ! -e 01 ];then
  echo "ERROR: Can't extract backup/01.tar.gz -> 01 initial backup files"
  read key
  exit
fi


if ls 01/* >/dev/null 2>&1; then
  cp -rf 01/* /
  rm -r 01
fi
 
echo "Done.
 "

# PREFIX must be 'export'ed for subfunctions executed in scripts

export PREFIX=NOPREFIX

all: prefix-check tree-check init-check
	@printf "\nBinary package, already built. Ready to install.\n\n"

install: prefix-check
	@mkdir -p $(PREFIX)
	@mk_backup initial
	@cd TREE && for i in $$(<../files.dat); do cp --parents $$i $(PREFIX); done
	@cd TREE && for i in $$(<../links.dat); do cp  --parents --no-dereference $$i $(PREFIX); done
	@for i in $$(<remove.dat); do rm $(PREFIX)/$$i; done
	@echo "Install done"
	@echo

uninstall: prefix-check force
	@for i in $$(<files.dat); do rm -f $(PREFIX)/$$i ; done
	@for i in $$(<links.dat); do rm -f $(PREFIX)/$$i ; done
	@for i in $$(<dirs.dat); do rmdir --ignore-fail-on-non-empty  $(PREFIX)/$$i >/dev/null 2>&1; done
	@echo
	@echo "*******************************************************"
	@echo "*** Run 'make restore' if you have backups you need ***"
	@echo "*** to restore at this time                         ***"
	@echo "*******************************************************"
	@echo

clean:
	@rm -f *~ */*~ */*/*~ */*/*/*~ */*/*/*/*~

prefix-check: force
	@if [ "_"$(PREFIX) == "_NOPREFIX" ] || [ "_"$(PREFIX) == "_" ] ; then \
	printf "\nError: Prefix not set in Makefile yet\n\n"; false; else true; \
	fi


tree-check:
	@if ! ls TREE/* >/dev/null 2>&1; then printf "\nError: No files in TREE yet.\n\n"; false; else true; fi

init-check:
	@if [ ! -e dirs.dat ] || [ ! -e files.dat ] || [ ! -e links.dat ]; then \
	echo; \
	echo "ERROR: Missing dat files."; \
	echo "Use 'make init' to create a default set"; \
	echo; \
	false; else true ; \
	fi

distclean: clean

import: files.dat links.dat dirs.dat prefix-check
	./mk_import working

backup: files.dat links.dat dirs.dat prefix-check force
	./mk_backup working

restore: prefix-check force
	./mk_restore working

files.dat links.dat dirs.dat:
	@echo
	@echo "Can't find dat files.  See README"
	@echo

init:
	@echo
	@echo "Creating default set of dat files"
	@echo "Recommend editing dirs.dat to remove system dirs, just in case."
	@echo "See README"
	@echo
	./mk_init working >/dev/null

force:

[security]
DisallowTCP=false

xhost +

kshell4 kwrite /etc/fstab

nohup kwrite /etc/fstab >/dev/null 2>&1 &

#!/bin/sh
# Click on this file to run it

# Copy the text that follows to the launcher file
cat << _EOF > ~/.launcher
#!/bin/sh
# this is a temporary launcher for a test. -rainbow sally
nohup "\$@" >/dev/null 2>&1 &
_EOF

# change perms to make it executable
chmod +x ~/.launcher

# run it to show a popup for three seconds and start a timeout for
# 4 seconds.  The four second timeout is to simulate actually doing 
# some task that takes a bit longer than the popup shows.

msg="
  Hang on, we're pretending to do 
  some work around here... 
  "

~/.launcher kdialog -passivepopup "$msg" 3

# now while that's running we timeout for 4 seconds.
sleep 4

# and report the good news... done at long-last.
kdialog -msgbox "
  All done!
  That will be 55 dollars and 35 cents, please.
  "

# this cleanup can be done at any time after the launcher has been called.
rm ~/.launcher

browse ~/.kde4

plugin=launcher

plugin=simplelauncher

--------------------

--------------------

HOME/bin/src/new-image
                +-- new.image (executable)
                +-- img-formats (formats we will be able to list & generate)
                      +-- template files

Usage:
  new.image [ <name.ext> | --help ]
  
  Creates a new 32x32 image file named <name.ext> of a type determined by
  <ext>.  
  
  To see a list of file types available type 
    new.image --types
  
  To see this help type
    new.image --help

#!/bin/sh

HERE=$PWD

APPPATH=`readlink "$0"`
if [ "$APPPATH" = "" ]; then
  APPPATH="$0"
fi

THERE=`dirname "$APPPATH"`

FMTLIST=

cd $THERE
for i in `ls img-formats/a.*`; do
  FMTLIST=`printf "%s\n%s" "$FMTLIST" "$i" | sed '/^$/d; s|^.*/a\.||;'"  "`
done
cd $HERE

print_types()
{
echo "
Available image formats:

$FMT
"
}

print_usage()
{
echo "
Usage:
  new.image [ <name.ext> | --help ]
  
  Creates a new 32x32 image file named <name.ext> of a type determined by
  <ext>.  
  
  To see a list of file types available type 
    new.image --types
  
  To see this help type
    new.image --help   
"
}

if [ "$1" = "" ]; then
  print_usage
elif [ "$1" = "--help" ]; then
  print_usage
elif [ "$1" = "--types" ]; then
  print_types
else
  EXT=`echo "$1" | sed 's|^.*\.||'`
  cp $THERE/img-formats/a.$EXT $HERE/$1
fi

new.symlink new.image ~/bin

/* XPM */
static char *dummy[]={
"32 32 1 1",
". c #ffffff",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................"};

new.image --types

new.image png

--- *snip* ---
SYNOPSIS
       mknod [OPTION]... NAME TYPE [MAJOR MINOR]

DESCRIPTION
--- *snip* ---
       c, u   create a character (unbuffered) special file
--- *snip* ---

$ ls -l /dev/null
crw-rw-rw- 1 root root 1, 3 2012-01-12 10:12 /dev/null

cd /opt/jboss/log/
rm program.log
mknod program.log c 1 3
chmod 666 program.log

SECURITY
     Certain security issues are common to many archiving programs, including tar.  In particular,
     carefully-crafted archives can request that tar extract files to locations outside of the target
     directory.  This can potentially be used to cause unwitting users to overwrite files they did
     not intend to overwrite.  If the archive is being extracted by the superuser, any file on the
     system can potentially be overwritten.  There are three ways this can happen.  Although tar has
     mechanisms to protect against each one, savvy users should be aware of the implications:

     ·       Archive entries can have absolute pathnames.  By default, tar removes the leading /
             character from filenames before restoring them to guard against this problem.

     ·       Archive entries can have pathnames that include .. components.  By default, tar will not
             extract files containing .. components in their pathname.

     ·       Archive entries can exploit symbolic links to restore files to other directories.  An
             archive can restore a symbolic link to another directory, then use that link to restore
             a file into that directory.  To guard against this, tar checks each extracted path for
             symlinks.  If the final path element is a symlink, it will be removed and replaced with
             the archive entry.  If -U is specified, any intermediate symlink will also be uncondi‐
             tionally removed.  If neither -U nor -P is specified, tar will refuse to extract the
             entry.
     To protect yourself, you should be wary of any archives that come from untrusted sources.  You
     should examine the contents of an archive with
           tar -tf filename
     before extraction.  You should use the -k option to ensure that tar will not overwrite any
     existing files or the -U option to remove any pre-existing files.  You should generally not
     extract archives while running with super-user privileges.  Note that the -P option to tar dis‐
     ables the security checks above and allows you to extract an archive while preserving any abso‐
     lute pathnames, .. components, or symlinks to other directories.

2.8.4 Extracting Archives from Untrusted Sources
------------------------------------------------

Extracting files from archives can overwrite files that already exist.
If you receive an archive from an untrusted source, you should make a
new directory and extract into that directory, so that you don't have
to worry about the extraction overwriting one of your existing files.
For example, if `untrusted.tar' came from somewhere else on the
Internet, and you don't necessarily trust its contents, you can extract
it as follows:

     $ mkdir newdir
     $ cd newdir
     $ tar -xvf ../untrusted.tar

   It is also a good practice to examine contents of the archive before
extracting it, using `--list' (`-t') option, possibly combined with
`--verbose' (`-v').

By default, GNU `tar' drops a leading `/' on input or output, and
complains about file names containing a `..' component.  There is an
option that turns off this behavior:

`--absolute-names'
`-P'
     Do not strip leading slashes from file names, and permit file names
     containing a `..' file name component.

Some people argue that GNU tar should not hesitate to overwrite files with other files when extracting. When extracting a tar archive, they expect to see a faithful copy of the state of the file system when the archive was created. It is debatable that this would always be a proper behavior. For example, suppose one has an archive in which ‘usr/local’ is a link to ‘usr/local2’. Since then, maybe the site removed the link and renamed the whole hierarchy from ‘/usr/local2’ to ‘/usr/local’. Such things happen all the time. I guess it would not be welcome at all that GNU tar removes the whole hierarchy just to make room for the link to be reinstated (unless it also simultaneously restores the full ‘/usr/local2’, of course!) GNU tar is indeed able to remove a whole hierarchy to reestablish a symbolic link, for example, but only if ‘--recursive-unlink’ is specified to allow this behavior. In any case, single files are silently removed.

#!/bin/sh
# The newer kdevelop is bulky and has bad shortcut keys.  We use
# the kde3 version.

CURDIR=`dirname "$0"`
cd "$CURDIR"
#this is buggy, let's get rid of it.
rm -f "$HOME"/.kde/share/config/kdevfileselectorrc
if kdevlite -v
  then 
    kdevlite "$CURDIR"/buffalo.kdevelop
  else
    kdevelop "$CURDIR"/buffalo.kdevelop
fi

  imlib2
  imlib2-loaders-1.4.4
  fribidi-0.10.9
  kdegraphics3-3.4.2
  expat-1.95.8
  kdegraphics3-imaging-3.4.2

PATH=.:~/bin:$PATH

#!/bin/sh
#new.symlink <FileInCurrentDir> <NewLinkLocation>

if [ $# != 2 ];then
    echo "Usage: new.symlink <FileInCurrentDir> <NewLinkLocation>"
    exit
fi

file="$PWD/$1"
dir="$2"

(cd $dir && ln -sf $file .)

new.symlink new.symlink ~/bin

#!/bin/sh
nohup $@ > /dev/null 2>&1 &
exit 0

#!/bin/sh

args=`echo $@ | sed 's|[:]| --line |; s|[:].*| |g;'`
launch "kate -n $args" ### we'll activate 'launch' later

grep -in fileincurrentdir ~/bin/*

edit <pasted text>

#!/bin/sh

BROWSER=konqueror

###############################################################
# read url and if first char is @, read the file instead of url

url="$1"
shift

has_splat()
{
    local tmp=`echo "$url" | sed "/@/! D"`
    if [ "$tmp" = "" ];then
        return 1; #err=no
    else
        return 0; #ok=yes
    fi
}


if has_splat ;then
    # check if first arg is @ alone
    if [ "$url" = "@" ];then
        url=$(<"$1")
        shift
    else # splat is prefixed to url
        url=`echo "$url" | sed "s/^@//"`
        url=$(<$url)
        shift
    fi

fi # has_splat


# compose a command line from url and other args, removing trailing
# spaces if any, so konqueror and other apps don't choke on a bum
# url.  That is a space at the end CAN be part of a valie url.

cmdln=`echo "$url $@" | sed 's/ *$//'`

# fork a system call (returns immediatly after creating new proc)
# and suppress error messages which would otherwise show in the 
# console.  (They could go directly to a log file, but stderr is
# the default for the console and the errors are usually non-fatal
# if they are anything more than warnings in the first place.)

launch "$BROWSER '$cmdln'"

int main() {
  401163:       55                      push   %rbp
  401164:       48 89 e5                mov    %rsp,%rbp
  401167:       53                      push   %rbx
  401168:       48 83 ec 58             sub    $0x58,%rsp
  struct archive * a = archive_read_new();
  40116c:       e8 1f fc ff ff          callq  400d90 <archive_read_new@plt>
  401171:       48 89 45 d8             mov    %rax,-0x28(%rbp)
  if(archive_read_support_compression_all(a) == ARCHIVE_WARN) {
  401175:       48 8b 45 d8             mov    -0x28(%rbp),%rax
  401179:       48 89 c7                mov    %rax,%rdi
  40117c:       e8 2f fb ff ff          callq  400cb0 <archive_read_support_compression_all@plt>
  401181:       83 f8 ec                cmp    $0xffffffffffffffec,%eax
  401184:       75 24                   jne    4011aa <main+0x47>
    fprintf(stderr, "warning: external compression support detected");
  401186:       48 8b 05 63 0f 20 00    mov    0x200f63(%rip),%rax        # 6020f0 <__bss_start>
  40118d:       48 89 c2                mov    %rax,%rdx
  401190:       b8 b0 15 40 00          mov    $0x4015b0,%eax
  401195:       48 89 d1                mov    %rdx,%rcx
  401198:       ba 2e 00 00 00          mov    $0x2e,%edx
  40119d:       be 01 00 00 00          mov    $0x1,%esi
  4011a2:       48 89 c7                mov    %rax,%rdi
  4011a5:       e8 16 fc ff ff          callq  400dc0 <fwrite@plt>
  }

df.installed() # find all installed or filter with substr
{ 
  # split into names and status lines
  local a=`dpkg --get-selections | sed 's|\t|\n|; /install/!d'`
  # delete status lines
  a=`echo "$a" | sed '/install$/d'`
  if [ "$1" != "" ];then
    a=`echo "$a" | sed '/'"$1"'/!d'`
  fi
  echo "$a"
}

for i in `df.installed`; do
  dpkg-repack $i
done

BUILD_TYPE="binary-i386"

show_params()
{
  echo "
  Examples.
    pkgtype pkgpath   distname  poolname
    .....................................................
    deb   file:///<path>  oneiric   main
    deb   file:///<path>  precise   test
    "
}

usage()
{
    echo
    echo "Need distname and poolname (params 3 and 4 in /etc/apt/sources.list)"
    show_params
}


create_package_files() # pkgpath poolname
{
  local pkgpath=$1
  local poolaname=$2
  local fsize
  local sum
  
  # echo $pkgpath/$poolname/pool; read key; cd pkgpath; return
  
  for i in `find $pkgpath/$poolname/pool/* -name *.deb`; do
  {
    # extract the control info
    ar -x $i control.tar.gz || return 1
    tar -xaf control.tar.gz ./control || return 1

    # add to ../Packages file removing null lines as we go.
    cat control | sed '/^$/d' >> Packages

    # need filename tag, relative path 
    echo "Filename: $i" | sed 's|.*\/pool\/|pool\/|' >> Packages
    
    # need exact file size, use disk usage (du) to get total for one file
    fsize=`du -cb $i | sed '/total/!d; s| *total||'`
    echo "Size: $fsize"
    
    # need at least md5sum, sha1sum and sha256sum appear to be optional
#    sum=`md5sum $i`
# remove filename from md5sum output -rs
    sum=`md5sum $i | cut -d' ' -f1`
    echo "MD5sum: $sum"

  }
  done
  
  # move up to where the Packages.gz and/or bz2 will be
  cd ..
  mv tmp/Packages .
  
  # cleanup
  rm -f tmp/*
  rmdir tmp
}


# mk_Package() # distname poolname
mk_pool()
{
  local pkgpath="$PWD"
  local distname=$1
  local poolname=$2
  local indexpath
  
  # syntax and error checks
  if [ "" == "$distname" ]; then 
    usage
    return 1
  fi

  if [ "" == "$poolname" ]; then 
    usage
    return 1
  fi
  if [ ! -x $poolname/pool ]; then 
    echo "Can't find '$poolname/pool' (deb files) folder"
    return 1
  fi
  indexpath=dists/$distname/$poolname/$BUILD_TYPE
  mkdir -p $indexpath/tmp
  rm -f $indexpath/tmp/*
  
  # copy all the control files into the tmp dir
  # operating from that directory temporarily
  
  cd $indexpath/tmp 
  create_package_files $pkgpath $poolname
  cd $pkgpath
  
}

/usr/lib/xscreensaver/atlantis

System Settings -> Desktop Effects -> / Advanced \

System Settings -> Desktop Effects -> / All Effects \

su # enter password
kdesu kwrite

# For openSUSE, run apps as user or 'su' 
# without kdesu/xdg-su or any other su 
# wrapper.
# Integrates gui and terminal apps the way 
# you'd expect them to be.
# How:
# add this to, or create /root/(dot)bashrc 
# containing this code.

function _su_check_connected
{
  dbus-send --dest=org.freedesktop /org/freedesktop org.freedesktop.Hello 2>/dev/null
}

function _su_check
{
  if [ "$USER" != "root" ]; then
    for i in /root/.dbus/session-bus/*; do
      source $i
      export DBUS_SESSION_BUS_ADDRESS
      if _su_check_connected ; then
        # we are now connected to the first dbus-daemon that worked
        return
      fi
    done
    # if no files contain a valid address, we'll just create one.
    export $(dbus-launch)
    # if root logs in before su does, root's daemon will get reused
    # otherwise there will be one for su and one for root.
    # two daemons is tolerable.  600+ is not.
  fi
}

_su_check

      |                                          |
 TERM |         DESCRIPTION                      |         EXAMPLE 
--------------------------------------------------------------------------------------
      | Distinguished name of an LDAP entry.     | dn: 
dn    | (Uniquely identifies it.)                | uid=tia,ou=users,dc=shushu,dc=local 
      |                                          |
--------------------------------------------------------------------------------------
      | Relative distinguished name of an LDAP   | rdn:
rdn   | entry. (Think of 'rdn' as relative name, | uid=tia
      | vs. 'dn' as fully-qualified name.)       |
--------------------------------------------------------------------------------------
      | Domain component. For instance, in the   | dc:
dc    | root DN "dc=shushu,dc=local", the first  | shushu
      | domain component is "shushu".            | 
--------------------------------------------------------------------------------------
      | Common name. An entry attribute that,    | cn: 
cn    | for user entries, is often first and     | Tia Sato
      | last name.                               | 
--------------------------------------------------------------------------------------
      | User account ID. Another entry attribute | uid: 
uid   | often used to identify users.            | t.sato
      |                                          |

#!/usr/bin/perl
 
use warnings ;
use strict ;
use Net::LDAP ;
 
my $auth_account = qq/cn=Mr Admin,dc=shushu,dc=local/ ; 
my $auth_pass    = qq/good.nice.password/ ;
 
# Connect to the OpenLDAP daemon
my $ldap_conn = Net::LDAP->new("localhost", port => 389, timeout => 15)
  or die "Unable to connect to LDAP server: $@" ;
 
# Login (aka "bind") to the directory
my $bind = $ldap_conn->bind($auth_account, password => $auth_pass ) ;
 
# Check code for success or failure (0 is success)
if($bind->code) {
  die $bind->error_name . ': ' . $bind->error_text ;
}

...
use Net::LDAPS ;
...
# Connect to the OpenLDAP daemon
my $ldap_conn = Net::LDAPS->new("localhost", port => 636, timeout => 15)
  or die "Unable to connect to LDAP server: $@" ;

# Code assumes active, authenticated Net::LDAP session in $ldap_conn..

my $cn = 'Beverly Xin' ;
 
my $search = $ldap_conn->search(
  base   =>     "ou=users,dc=shushu,dc=local",
  scope  =>     "one",
  filter =>     "cn=$cn") ;
 
# Unbind when finished with the query
$ldap_conn->unbind() ;

print $search->error_name . ': ' . $search->error_text . "\n" ;
 
foreach($search->entries) {

  print $_->ldif() ;
 
}

# Code assumes active, authenticated Net::LDAP session in $ldap_conn..

my $dn = 'cn=Sasha Lee,ou=users,shushu,dc=local' ;
my $cn = 'Sasha lee' ;
my $sn = 'Lee' ;
my $uid = 's.lee' ;
my $mail = 'sasha.lee@shushu.local' ;
my @dept = ['Info Tech', 'Financial'] ;
my $objclass = 'inetOrgPerson' ;
 
my $add =
  $ldap_conn->add( $dn,
         attr => [ 'cn' => $cn, 
                   'sn' => $sn, 
                   'uid' => $uid,
                   'mail' => $mail,
                   'departmentNumber' => @dept,
                   'objectClass' => $objclass ] ) ;
 
# add() failure checking ('code' is 0 upon success)
if($add->code) {
  die $add->error_name . ': ' . $add->error_text ;
}

# Code assumes active, authenticated Net::LDAP session in $ldap_conn..

my $dn = 'cn=Sasha Lee,ou=users,shushu,dc=local' ;
 
my $delete = $ldap_conn->delete($dn) ;
 
# delete() failure checking ('code' is 0 upon success)
if($delete->code) {
  die $delete->error_name . ': ' . $delete->error_text ;
}

# Code assumes active, authenticated Net::LDAP session in $ldap_conn..

my $dn = 'cn=Crystal Zhao,ou=users,dc=shushu,dc=local' ;
 
# Replace attribute (i.e. change an existing value to a new value)
my $mod = $ldap_conn->modify($dn, 
            replace => { 'mail' => 'hmm@localhost' } ) ;
 
# Status checking ('code' is 0 upon success)
if($mod->code) {
  die $mod->error_name . ': ' . $mod->error_text ;
}
 
# ------------------------------------------------------------------- #
 
# Add attribute values
$mod = $ldap_conn->modify($dn, 
          add => { 'departmentNumber' => ['Unknown', 'Payroll'] } ) ;
 
# Status checking ('code' is 0 upon success) and commit
if($mod->code) {
  die $mod->error_name . ': ' . $mod->error_text ;
}
 
# ------------------------------------------------------------------- #
 
# Delete attribute by value
$mod = $ldap_conn->modify($dn, 
          delete => { 'departmentNumber' => 'Unknown' } ) ;
 
# Status checking ('code' is 0 upon success) and commit
if($mod->code) {
  die $mod->error_name . ': ' . $mod->error_text ;
}
 
# Alternatively, we can delete all attribute values
$mod = $ldap_conn->modify($dn, 
          delete => [ 'departmentNumber' ] ) ;
 
# Status checking ('code' is 0 upon success) and commit
if($mod->code) {
  die $mod->error_name . ': ' . $mod->error_text ;
}

#include <stdio.h>
#include <string.h>

int main (int argc, char *argv[])
{
   if (argc >= 2)
   { 
      int i;
      for (i = 1; i < argc; i++)
         printf ("\nHaalloo! %s", argv[i]);
   }
   else
      printf ("\nForgot to key in something?");

   return 0;
}

anisha@linux-dopx:~/> gcc -g test.c 
anisha@linux-dopx:~/> gdb a.out -silent
Reading symbols from /home/anisha/a.out...done.
(gdb) r
Starting program: /home/anisha/a.out 

Forgot to key in something?

Program exited normally.
(gdb) r anisha kaul
Starting program: /home/anisha/a.out anisha kaul

Haalloo! anisha
Haalloo! kaul 

Program exited normally.
(gdb)