// This file is part of the program FRYSK.
//
// Copyright 2007, Red Hat Inc.
//
// FRYSK is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; version 2 of the License.
//
// FRYSK is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with FRYSK; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
// 
// In addition, as a special exception, Red Hat, Inc. gives You the
// additional right to link the code of FRYSK with code not covered
// under the GNU General Public License ("Non-GPL Code") and to
// distribute linked combinations including the two, subject to the
// limitations in this paragraph. Non-GPL Code permitted under this
// exception must only link to the code of FRYSK through those well
// defined interfaces identified in the file named EXCEPTION found in
// the source code files (the "Approved Interfaces"). The files of
// Non-GPL Code may instantiate templates or use macros or inline
// functions from the Approved Interfaces without causing the
// resulting work to be covered by the GNU General Public
// License. Only Red Hat, Inc. may make changes or additions to the
// list of Approved Interfaces. You must obey the GNU General Public
// License in all respects for all of the FRYSK code and other code
// used in conjunction with FRYSK except the Non-GPL Code covered by
// this exception. If you modify this file, you may extend this
// exception to your version of the file, but you are not obligated to
// do so. If you do not wish to provide this exception without
// modification, you must delete this exception statement from your
// version and license this file solely under the GPL without
// exception.

package frysk.util;

import frysk.proc.Action;
import frysk.proc.Manager;
import frysk.proc.SyscallEventInfo;
import frysk.proc.Task;
import frysk.proc.TaskObserver;
import frysk.rt.Frame;
import frysk.rt.StackFactory;

public class CatchError
{

  private static String myError;
  public static void main (String[] args)
  {
    myError =  args[0];
    
    Manager.host.requestCreateAttachedProc(new String[]{args[1],args[2]}, attachedObserver);
    Manager.eventLoop.run();
  }

  static TaskObserver.Attached attachedObserver = new TaskObserver.Attached(){

    public Action updateAttached (Task task)
    {
      System.out.println(".updateAttached()");
      task.requestAddSyscallObserver(syscallObserver);
      return Action.BLOCK;
    }
    
    public void addFailed (Object observable, Throwable w){}
    public void addedTo (Object observable){
      System.out.println(".addedTo()");
    }
    public void deletedFrom (Object observable){}
    
  };
  
  static TaskObserver.Syscall syscallObserver = new TaskObserver.Syscall(){

    public Action updateSyscallEnter (Task task)
    {
      SyscallEventInfo eventInfo = task.getSyscallEventInfo();
      frysk.proc.Syscall syscall = eventInfo.getSyscall(task);
      
      if(syscall.getName().equals("write")){
        long address = syscall.getArguments(task, 2);
        
        StringBuffer x = new StringBuffer ();
        task.getMemory().get (address, 200, x);
        String xString = new String(x);
        
        if(xString.contains(myError)){
          System.out.println("WOW this process is trying to output " + x);
          Frame frame = StackFactory.createFrame(task);
          System.out.println("here is a stack trace:\n" + StackFactory.printStackTrace(frame));
        }
        
      }
      return Action.CONTINUE;
    }

    public Action updateSyscallExit (Task task)
    {
      return Action.CONTINUE;
    }

    public void addFailed (Object observable, Throwable w){}
    public void addedTo (Object observable){
      Task task = (Task) observable;
      task.requestUnblock(attachedObserver);
    }
    public void deletedFrom (Object observable){}
    
  };
}