74 else

75 {

76 mtr_error("can't fork timer, error: $!");

77 }

78 }

123

124 # As the timers are so simple programs, we trust them to terminate,

125 # and use blocking wait for it. We wait just to avoid a zombie.

126 waitpid($tpid,0);

127

132 }

133

134 mtr_error("Asked to stop timer '$name' not started");

135 }

136

40

41 my $log_dir = "cmds_log.$$";

42 mkdir($log_dir) or die "Error, cannot mkdir $log_dir";

43

44 ## This is very cheap 'parallel-computing' !!! :)

65 ## process list of completed commands

66 if(-f ($completed_file_name)){

67 open (my $fh, "<", $completed_file_name) or die "Error, cannot open completion file for reading $completed_file_name";

68 while (<$fh>) {

69 chomp;

72 }

73 ## load all commands in memory... filesystem glitches can otherwise result in premature termination with inadvertent success status.

74 open (my $fh, $cmds_file) or die "Error, cannot open file $cmds_file";

75

76 while (my $cmd = <$fh>) {

49 1;

50 } or do {

51 my $error = $@ || 'Zombie Error';

52 blessed $self

53 and $self->log_cb->( core => "Failed to serialize content: $error" );

68 1;

69 } or do {

70 my $error = $@ || 'Zombie Error';

71 $self->log_cb->( core => "Failed to deserialize content: $error" );

29

30 my @cpu_instances = ('user', 'nice', 'system', 'idle', 'wait', 'interrupt', 'softirq', 'steal');

31 my @if_instances = ('if_octets', 'if_packets', 'if_errors');

32 my $vzctl = '/usr/sbin/vzctl';

33 my $vzlist = '/usr/sbin/vzlist';

148 # processes

149

150 my $ps_states = { 'paging' => 0, 'blocked' => 0, 'zombies' => 0, 'stopped' => 0,

151 'running' => 0, 'sleeping' => 0 };

152 my $state_map = { 'R' => 'running', 'S' => 'sleeping', 'D' => 'blocked',

153 'Z' => 'zombies', 'T' => 'stopped', 'W' => 'paging' };

154

155 $v{'plugin'} = 'processes';

53 'port' => 53,

54 'whoami' => "DNSSERVER",

55 'error' => "",

56 'enable' => 0,

57 'resolve_to' => "127.0.0.1",

81 my $shellz = shift;

82

83 #ignore child process avoid zombies.

84 $SIG{CHLD} = 'IGNORE';

85

114 while(1) {

115 if( $nserver->answer_queries() == 0 ){

116 $self->{'Base'}->{'error'} = "[$self->{'Base'}->{'whoami'}] - Error Initiating DNS Server";

117 return 0;

118 }

2 =head1 NAME

3

4 CXGN::Error::Tag

5

6 =head1 AUTHOR

7

8 John Binns <zombieite@gmail.com>

9

10 =head1 DESCRIPTION

11

12 Allows you to send tagged error messages to STDERR. We may someday want to

13 grep through error logs to find these tagged messages.

23 And, it won't matter too much if you forget to comment it out later.

24

25 use CXGN::Error::Tag ('dbg','wrn');

26 dbg;#prints just empty dbg tags, as long as you are not a production server.

27 dbg('my debug message');#prints a message in dbg tags

27 my ($me, $file, $restrict, $text) = @_;

28 #print "[LineParser($me->{class}): opening $file]\n";

29 $me->{errors} = [];

30

31 if ($file =~ /\.loose\./) {

57 =test

58 if ($bib->{entryIndex}->{TIMWAT}) {

59 print "found future zombie\n";

60 print $bib->{entryIndex}->{TIMWAT}->toString;

61 print "\n";

105 my $target = $current_cat;

106 for (; $level_diff >=0; $level_diff--) {

107 $target = $target->firstParent || die("** ERROR (line #: $linenum): can't get appropriate parent for category '$ca->{name}|$l'\n");

108 }

109 # add to appropriate parent

35 print: $^STDOUT, $_

36

37 close $pipe # avoid zombies

38 else

39 printf: $^STDOUT, "not ok \%d - open -|\n", (curr_test: )

59

60 print: $^STDOUT, $_

61 close $pipe # avoid zombies

62 else

63 printf: $^STDOUT, "not ok \%d - $raw", (curr_test: )

70 if ((open: $pipe, "|-", "-"))

71 printf: $pipe, "not ok \%d - $raw", (curr_test: )

72 close $pipe # avoid zombies

73 else

74 $_ = join: '', @: ~< $^STDIN

37 my $c; #connection

38

39 $SIG{CHLD} = 'IGNORE'; # Don't reap zombies

40

41 msg("Entering accept loop (port $port)");

153 --loglvl, -log [Default=4] The logging level.

154 0 - Suppress all logging.

155 1 - Errors only,

156 2 - Messages and errors only,

157 3 - Debugging messages, messages and errors,

158 4(and above) - Add log dump to stdout.

159

44 # If a second child dies while in the signal handler caused by the

45 # first death, we won't get another signal. So must loop here else

46 # we will leave the unreaped child as a zombie. And the next time

47 # two children die we get another zombie. And so on.

143 {

144 doit_one($team);

145 }else #error

146 {

147 print "Internal Error: Can`t fork!\n";

41 # files to replace their "fallback" counterparts before distributing your

42 # changes.

43 my @names = (qw(SG_ERROR_ASPRINTF SG_ERROR_DEVSTAT_GETDEVS

44 SG_ERROR_DEVSTAT_SELECTDEVS SG_ERROR_ENOENT

45 SG_ERROR_GETIFADDRS SG_ERROR_GETMNTINFO SG_ERROR_GETPAGESIZE

46 SG_ERROR_KSTAT_DATA_LOOKUP SG_ERROR_KSTAT_LOOKUP

47 SG_ERROR_KSTAT_OPEN SG_ERROR_KSTAT_READ

48 SG_ERROR_KVM_GETSWAPINFO SG_ERROR_KVM_OPENFILES

49 SG_ERROR_MALLOC SG_ERROR_NONE SG_ERROR_OPEN SG_ERROR_OPENDIR

50 SG_ERROR_PARSE SG_ERROR_SETEGID SG_ERROR_SETEUID

51 SG_ERROR_SETMNTENT SG_ERROR_SOCKET SG_ERROR_SWAPCTL

52 SG_ERROR_SYSCONF SG_ERROR_SYSCTL SG_ERROR_SYSCTLBYNAME

53 SG_ERROR_SYSCTLNAMETOMIB SG_ERROR_UNAME SG_ERROR_UNSUPPORTED

176 @par{'code_sref','error_sref'};

177

178 my @errors = split (/\n/, $$error_sref);

179 my @code = split (/\n/, $$code_sref);

180

181 my $found_error;

182 my @messages;

183

184 foreach my $error ( @errors ) {

185 next if $error =~ /BEGIN not safe/;

223 }

224

225 if ( not $found_error and $$error_sref ne '' ) {

226 push @messages, CIPP::Compile::Message->new (

227 type => 'perl_err',

168 }

169 } else {

170 print "error: $@\n";

171 }

172 }

206 shift;

207

208 $kernel->post (fetchrss => 'ZOMBIE');

209 $self->SUPER::_state_end (@_);

210 }

23 my $sleeping=-1;

24 my $running=-1;

25 my $zombie=-1;

26 my $stopped=-1;

27

36 $loadavg1=$2;

37 $loadavg2=$3;

38 }elsif ($line =~ /(^\d\d*)\s\s*processes:\s\s*(\d\d*)\s\s*sleeping,\s\s*(\d\d*)\s\s*running,\s\s*(\d\d*)\s\s*zombie,\s\s*(\d\d*)\s\s*stopped/) {

39 $processes=$1;

40 $sleeping=$2;

41 $running=$3;

42 $zombie=$4;

43 $stopped=$5;

44 }elsif ($line =~ /\s*PID\s\s*USER.*COMMAND/) {

38 print;

39 }

40 close PIPE; # avoid zombies

41 }

42 else {

63 print;

64 }

65 close READER; # avoid zombies

66 }

67 else {

122 sleep 5;

123 if (print NIL 'foo') {

124 # If print was allowed we had better get an error on close

125 ok( !close NIL, 'close error on broken pipe' );

145

146 # check that status for the correct process is collected

147 my $zombie;

148 unless( $zombie = fork ) {

37

38 if ( @$kids >= $self->max_clients ) {

39 $proxy->log( HTTP::Proxy::ERROR, "PROCESS",

40 "Too many child process, serving the connection" );

41 $proxy->serve_connections($fh->accept);

49 if ( !defined $child ) {

50 $conn->close;

51 $proxy->log( HTTP::Proxy::ERROR, "PROCESS", "Cannot fork" );

52 $self->max_clients( $self->max_clients - 1 )

53 if $self->max_clients > @$kids;

70 }

71

72 $self->reap_zombies if @$kids;

73 }

74

53 # Go over all pids: validate each pid by sending signal 0, unlink

54 # pidfile if pid does not exist and return 0. Count the number of

55 # zeros (= removed files = zombies) with grep.

56 my $zombies = grep /^0$/,

57 (map {/(\d+)$/ and kill 0,$1 or Unlink($_) and 0} @pids);

58 if (scalar(@pids)-$zombies >= $InstanceThrottleLimit) {

59 ReportError(Ts('Too many instances. Only %s allowed.',

6 =head1 DESCRIPTION

7

8 This module is used mainly by CXGN::Apache::Error to provide detailed information about who caused a page error and how they caused it.

9

10 =head1 NON-OBJECT METHODS

24 =head2 time

25

26 Returns a string indicating the time in Ithaca NY. Used to associate a time with an error report.

27

28 =head1 AUTHOR

29

30 john binns - John Binns <zombieite@gmail.com>

31

32 =cut

30 my $self = {

31 'module' => $module,

32 'error' => $error

33 };

34

52

53 if (ref($Apache::Voodoo::Engine::debug)) {

54 $Apache::Voodoo::Engine::debug->error($self->{'module'},$self->{'error'});

55 }

56

57 Apache::Voodoo::Exception::Compilation->throw(

58 'module' => $self->{'module'},

59 'error' => $self->{'error'}

60 );

61 }

39 print;

40 }

41 close $PIPE; # avoid zombies

42 }

43 else {

68 }

69 print;

70 close $PIPE; # avoid zombies

71 }

72 else {

82 if (open($PIPE, "|-")) {

83 printf $PIPE "not ok %d - $raw", curr_test();

84 close $PIPE; # avoid zombies

85 }

86 else {

34 1

35 } or do {

36 my $err = $@ || 'Zombie error';

37 die "Failed to merge typ";

38 }

34 - replyto address to include in the email

35 Ret : nothing meaningful

36 Side Effects: dies on error

37 Example:

38

103

104 if ($mail == -1) {

105 print STDERR "CXGN::Contact: SMTP error: $error\n";

106 };

107

123

124 if ($mail == -1) {

125 print STDERR "CXGN::Contact: SMTP error: $error\n";

126 };

127

38 print;

39 }

40 close PIPE; # avoid zombies

41 }

42 else {

63 }

64 print;

65 close PIPE; # avoid zombies

66 }

67 else {

75 if (open(PIPE, "|-")) {

76 printf PIPE "not ok %d - $raw", curr_test();

77 close PIPE; # avoid zombies

78 }

79 else {

52 # Go over all pids: validate each pid by sending signal 0, unlink

53 # pidfile if pid does not exist and return 0. Count the number of

54 # zeros (= removed files = zombies) with grep.

55 my $zombies = grep /^0$/,

56 (map {/(\d+)$/ and kill 0,$1 or unlink and 0} @pids);

57 if (scalar(@pids)-$zombies >= $InstanceThrottleLimit) {

58 ReportError(Ts('Too many instances. Only %s allowed.',

133 # num_unsuccess=>0,

134 # destination_addr=>$pdu->{source_addr},

135 error_status_code => 0,

136 seq => $pdu->{seq} ) }, },

137 0x80010004 => { cmd => 'submit_sm_resp_v4', reply => undef, },

188 or die "Can't create server: $!";

189

190 $SIG{CHLD} = 'IGNORE'; # Don't reap zombies

191

192 warn "$$: Entering accept loop";

60 # sanity check

61 if ($MAXJOBS < $SIMULTANEOUSJOBS) {

62 return("ABORT|CONFIGERROR");

63 $log->log("Notify the administrator that the MAXJOBS settings is too low given the SIMULTANEOUSJOBS setting");

64 }

90

91 ############################################################################

92 # Clean up some 'zombies' (internal function)

93 ############################################################################

94 sub cleanqueue {

124 unless(CXGN::DB::Tools::is_valid_column($dbh,$table_name,$column_name))

125 {

126 CXGN::Apache::Error::notify('found invalid parameter',"Someone sent in '$column_name' as a parameter. Wacky.");

127 $sortby='';

128 }

152 =head1 AUTHOR

153

154 Robert Buels and John Binns <zombieite@gmail.com>

155

156 =cut

38 format(TL, _Str, _Arg):-

39 var(TL), !,

40 throw(error(instantiation_error, 'toplevel_proc:format'/3-1)).

41 format(TL, Str, Args):-

42 Status = ~get_status(TL), !,

50 flush_output(~get_input(TL)).

51 format(TL, _Str, _Args):-

52 throw(error(domain_error(toplevel_proc, TL), 'toplevel_proc:format'/3-1)).

53

54 get_input(toplevel(Stream, _, _, _, _)) := Stream.

73 true

74 ;

75 throw(error(unknown_error, 'toplevel_proc:start'/1))

76 ).

77

32 new => { transitions => { _on_cmd_start => 'starting',

33 _on_cmd_stop => 'stopping/db',

34 _on_cmd_catch_zombie => 'zombie' } },

35

36 starting => { advance => '_on_done',

105

106 stopping => { advance => '_on_done',

107 transitions => { _on_error => 'zombie/reap' },

108 delay => [qw(_on_lxc_done)],

109 substates => [ shutdown => { transitions => { on_hkd_kill => 'stop' },

252 config => $self->{config},

253 heavy => $self->{heavy},

254 on_error => weak_method_callback($self, '_on_error'),

255 on_running => weak_method_callback($self, '_on_done'),

256 image_path => $self->{os_image_path},

70 }

71

72 if ($self->{'object'}->isa("Apache::Voodoo::Zombie") || $self->{'object'}->can($method)) {

73 # Either we have a dead module and the Zombie will answer to whatever was requested,

126 };

127 if ($@) {

128 my $error= "There was an error loading one of the base classes for this page ($_):\n\n$@\n";

129

130 my $link = $self->{'module'};

135 }

136

137 # FIXME replace with a instance of Apache::Voodoo::Zombie

138 $self->debug("ZOMBIE: $self->{'module'} $method");

139 return $self->display_error($error,"/$link");

140 }

141 }

31 # Makefile, and allows for detecting whether the module is loaded from

32 # perl/Git as opposed to perl/build/Git, which is useful for one-off

33 # testing without having Error.pm et al installed.

34 use constant NO_PERL_CPAN_FALLBACKS_STR => '@@' . 'NO_PERL_CPAN_FALLBACKS' . '@@';

35 use constant NO_PERL_CPAN_FALLBACKS => (

56 1;

57 } or do {

58 my $error = $@ || "Zombie Error";

59

60 if (NO_PERL_CPAN_FALLBACKS) {

61 chomp(my $error = sprintf <<'THEY_PROMISED', $module);

62 BUG: The '%s' module is not here, but NO_PERL_CPAN_FALLBACKS was set!

63

167 'sleep 2 & ps -C sleep | wc -l sleep 3 ps -C sleep | wc -l' ],

168

169 # Zombie

170 # Method 1

171 [ 'cat temp1.out | ./ospsh -q & sleep 2 ; ps -C echo | grep "<defunct>$"',

206 $result =~ s|\s+$||;

207 next if $result eq $want;

208 next if $want eq 'Syntax error [NULL]' && $result eq '[NULL]';

209 next if $result eq $want;

210 print STDERR "Test $ntest FAILED!\n input was \"$in\"\n expected output like \"$want\"\n got \"$result\"\n";

137 # if command required user and no user could be determined -> abort

138 if ( $cmd =~ /%user%/ && ! $user ) {

139 $self->logger->error( "Could not determine user for recipient ". $self->to. ", command line '$cmd'. ABORT!" );

140 return ( 0 );

141 }

168 else {

169 {

170 # yeah, zombie mess..

171 local $SIG{ CHLD } = 'IGNORE';

172 open $input_handle, '|-', "$cmd 1>\"$tn\" 2>\"$tn\"";

193 $self->logger->debug3( "Run command '$cmd_file'" );

194 {

195 # zombies are creepy

196 local $SIG{ CHLD } = 'IGNORE';

197 `$cmd_file 1>"$tn" 2>"$tn"`;

45 };

46 if ($@) {

47 my $error = "$@";

48 $error =~ s/Compilation failed in require at .*Apache\/Voodoo\/Loader.pm line.*//;

52 require Apache::Voodoo::Zombie;

53 $obj = Apache::Voodoo::Zombie->new($module,$error);

54 }

55

51 $self->_run_cmd([$self->_cfg('command.lxc-wait'), -n => $self->{lxc_name}, 'STOPPED'],

52 timeout => $self->_cfg('internal.hkd.vmhandler.timeout.on_state.stopping'),

53 ignore_errors => 1);

54 }

55

67 $debug and $self->_debug("too many retries, no more killing, peace!");

68 WARN "Too many retries when killing cointainer processes: @pids";

69 return $self->_on_kill_lxc_processes_error;

70 }

71 chomp @pids;

72 $debug and $self->_debug("killing zombie processes and then trying again, pids: @pids");

73 DEBUG "Killing zombie processes: PIDs @pids";

87 $self->_run_cmd([$self->_cfg('command.lxc-destroy'), -n => $lxc_name],

88 timeout => $self->_cfg('internal.hkd.lxc.killer.destroy_lxc.timeout'),

89 ignore_errors => 1);

90 }

91

49 }

50

51 # Automatically clean up zombie children

52 #

53 $SIG{CHLD} = 'IGNORE';

120 }

121

122 # This is an error condition.

123 #

124 # I was unable to read any "PTY is /dev/pts/#" lines in the

6 =head1 NAME

7

8 Sendmail::M4::mail8_zombie - Stop fake MX and most spammers, sendmail M4 hack file

9

10 =head1 STATUS

60 {

61 my $whoops = join ",", @_;

62 print "ERR.WHOOPS PROGRAM ERROR: $whoops\n";

63 exit 0;

64 }

153 if ( scalar $ok )

154 {

155 print "ERR.IP <HOST $helo with IP $ip> matched mail8_zombie: $_\n";

156 exit 0;

157 }

124 SDL::TTF::render_text_blended

125 ($font_p, "$texto_mortes $score. $tempo $texto_segundos", $color)

126 or die 'TTF render error: ' . SDL::get_error();

127 my $timer_w = $timer->w;

128 my $timer_h = $timer->h;

136 my ($self) = @_;

137 my $tilesize = $self->dados->{tilesize};

138 my $sp_count = scalar @{$self->dados->{zombie}};

139 my $sp_num = int(rand($sp_count - 1)+0.5);

140 return map { $_ * $tilesize } split /,/, $self->dados->{zombie}[$sp_num]{posicao};

108 pd "Executing: $speak";

109 pd "Word pause set to $wpause milliseconds";

110 my $pid = open3(\*WRITE, \*READ,\*ERROR,"$speak") || die "$!";

111

112 my $sel = new IO::Select();

113

114 $sel->add(\*READ);

115 $sel->add(\*ERROR);

116

117 print STDERR "\nEnter text\n";

130 #pd("Input buffer found");

131 my $buf = '';

132 if ($h eq \*ERROR) {

133 sysread(ERROR,$buf,4096);

134 if($buf){

135 pd("ERROR-> $buf");

136 }

137 } else {

116 SDL::TTF::render_text_blended

117 ($font_p, "Mortes: $score. $tempo segundos", $color)

118 or die 'TTF render error: ' . SDL::get_error();

119 my $timer_w = $timer->w;

120 my $timer_h = $timer->h;

128 my ($self) = @_;

129 my $tilesize = $self->dados->{tilesize};

130 my $sp_count = scalar @{$self->dados->{zombie}};

131 my $sp_num = int(rand($sp_count - 1)+0.5);

132 return map { $_ * $tilesize } split /,/, $self->dados->{zombie}[$sp_num]{posicao};

35

36 eval "require $bucket_class; 1;" or do {

37 my $err = $@ || "Zombie error";

38 die "Could not load bucket implementation '$bucket_class': $err"

39 };

57 my $job_id = $opt->{coord} || die "No coordinator ID!";

58

59 my($job, $job_error);

60 eval {

61 $job = $oozie->job_exists(

68 1;

69 } or do {

70 $job_error = $@ || 'Zombie error';

71 };

72

74 warn sprintf 'Could not retrieve details for coord id %s. %s',

75 $job_id,

76 $job_error ? "Error: $job_error" : 'Job does not exist.',

77 ;

78 return;

34 $class->SUPER::connect("dbi:Pg:dbname=$db_name;host=$db_host;connect_timeout=$db_connect_timeout",

35 $db_user, $db_passwd,

36 { RaiseError => 1,

37 AutoCommit => 1,

38 quote_char => '"',

60 running

61 stopping

62 zombie

63 debugging )],

64 VM_Cmd => [qw(start stop busy)],

109 $dbh->do("DROP TABLE $table CASCADE");

110 };

111 warn "Error (DROP $table): $@" if $@;

112 }

113 }

32 - replyto address to include in the email

33 Ret : nothing meaningful

34 Side Effects: dies on error

35 Example:

36

54

55 #if we are specifying a mailto as a vhost configuration variable (such as 'bugs_email'), then use that variable's value, and append the request info.

56 #mailto can also be specified normally (such as 'John Binns <zombieite@gmail.com>').

57 if ( $mailto and eval{ $vhost_conf->get_conf($mailto)} ) {

58 $mailto = $vhost_conf->get_conf($mailto);

105 =head1 AUTHOR

106

107 john binns - John Binns <zombieite@gmail.com>

108

109 =cut

64 else

65 {

66 mtr_error("can't fork");

67 }

68 }

105

106 # As the timers are so simple programs, we trust them to terminate,

107 # and use blocking wait for it. We wait just to avoid a zombie.

108 waitpid($tpid,0);

109

34 my %h;

35 tie %h, 'SimpleCDB', 'db', O_WRONLY|O_TRUNC

36 or die "tie failed: $SimpleCDB::ERROR\n";

37

38 my $n = $records/$columns;

46 substr($v, rand(length($v)), 1) = $magic;

47 $h{$k} = $v;

48 die "store: $SimpleCDB::ERROR" if $SimpleCDB::ERROR;

49 $m += $n, print '.' if ($i == int $m);

50 }

100 my $i = int rand($records);

101 my $v = $h{$i};

102 die "fetch: $SimpleCDB::ERROR" if $SimpleCDB::ERROR;

103 #print "$$\t$i = " . (defined $v ? 'ok' : '-') . "\n";

104 print '+';

65 All IO handles will be connected to I</dev/null> with one exception: if C<STDERR>

66 was already redirected to a file (and is not a terminal) then it is left untouched.

67 This is to make sure error messages still go to the desired log files.

68

69 B<Note on SIGCHLD>

70

71 For the parent process we set C<$SIG{CHLD} = "IGNORE"> to prevent zombie child

72 processes.

73

87 my ($self) = @_;

88

89 $SIG{CHLD} = 'IGNORE'; # IGNORE means: child zombies are auto-removed from process table

90

91 my $pid = $self->_try_fork($self->max_fork_redo);

19 "skelwa_melee.ssl:fl#sklwm.baf",

20 "skelwa_ranged.ssl:fl#sklwr.baf",

21 "zombie_sea.ssl:fl#zomse.baf",

22 "fl#lowm.ssl:fl#lowm.baf",

23 "fl#lowr.ssl:fl#lowr.baf",

54 my $from_dir = $_[2];

55 File::Path::make_path($to_dir);

56 File::Path::make_path($from_dir . "/ssl_out"); #perl on win does not automatically create it and instead errors out

57 foreach (@files) {

58 my @collection = split(":");

23 'W' => 'magenta bold', # paging

24 'X' => 'white on_red', # dead

25 'Z' => 'white', # zombie

26 '<' => 'red', # not nice

27 'N' => 'green', # nice

127

128 # Skip blabber about bad syntax

129 return if /^(?:Warning|ERROR):/;

130

131 # Parse the headings

59 1;

60 } or do {

61 my $eval_error = $@ || 'Zombie error';

62 confess q{server response wasn't valid JSON: } . $eval_error;

69 my $code = $response->code;

70

71 # collect additional error info

72 my @msg;

73 push @msg, $1

74 if $content =~ m{\Q<b>description</b>\E\s+<u>(.+?)</u>}xmsi;

75

76 push @msg, $headers->{'oozie-error-message'}

77 if $headers->{'oozie-error-message'};

23 foreach my $parser (@parsers) {

24 if (not eval "require $parser; 1;") {

25 my $err = $@ || "Zombie error";

26 die "Couldn't require '$parser': $err";

27 }

10

11

12 print "// ZombieGotcha Sprite Translator \n\n";

13

14 my $pnmtype, $line;

16 #First, verify the filetype

17 $pnmtype=<>;

18 print STDERR "ERROR: Type is not P3. Use ASCII GIMP PNM in RGB!." if $pnmtype ne "P3\n";

19

20 # P1 Portable bitmap ASCII

264 print "not ok ",$test_count++," # \$/ = {}; produced expected error message\n";

265 } else {

266 my $msg= $@ || "Zombie Error";

267 print "ok ",$test_count++," # \$/ = {}; should die\n";

268 if ($msg!~m!Setting \$\/ to a HASH reference is forbidden!) {print "not ";}

282 print "not ok ",$test_count++," # \$/ = qr/foo/; produced expected error message\n";

283 } else {

284 my $msg= $@ || "Zombie Error";

285 print "ok ",$test_count++," # \$/ = qr/foo/; should die\n";

286 if ($msg!~m!Setting \$\/ to a REGEXP reference is forbidden!) {print "not ";}

291 print "not ok ",$test_count++," # \$/ = \\*STDOUT; produced expected error message\n";

292 } else {

293 my $msg= $@ || "Zombie Error";

294 print "ok ",$test_count++," # \$/ = \\*STDOUT; should die\n";

295 if ($msg!~m!Setting \$\/ to a GLOB reference is forbidden!) {print "not ";}

10 1;

11 } or do {

12 my $error = $@ // "Zombie Error";

13

14 warn "Unable to load the XS version of <" . __PACKAGE__ . ">. Falling back on the pure-perl version!: <$@>";

89 Throws : We should probably throw an exception if the ip address under test is unreachable

90 Comments : Not all open proxies or compromised hosts listen on port 80 and their are other means

91 than straightforward HTTP to communicate with zombies but this is a start.

92

93 See Also : HTTPD::ADS::AbuseNotify for sending complaints about validated proxies and other abuse.

129 sub guilty {

130 my $self = shift;

131 #we should get an error if its not an open proxy; informational etc. is not the right thing....

132 return ! ( ($self->get_response)->is_error);

84 return 1;

85 }

86 elsif ($self->{'object'}->isa("Apache::Voodoo::Zombie") || $self->{'object'}->can($method)) {

87 # Either we have a dead module and we map whatever was requested or

88 # we have a live one and has the requested method.

156 };

157 if ($@) {

158 my $error= "There was an error loading one of the base classes for this page ($_):\n\n$@\n";

159

160 my $link = $self->{'module'};

165 }

166

167 # FIXME replace with a instance of Apache::Voodoo::Zombie

168 $self->debug("ZOMBIE: $self->{'module'} $method");

169 return $self->display_error($error,"/$link");

170 }

171 }

8 #

9 # v1.0 Initial version

10 # v1.1 Avoid leaving zombies

11

12 use strict;

142 waitpid $pid, 0;

143

144 if ($output =~ /^Error:/) {

145 $output =~ s/^Error: //;

146 Irssi::print("challenge: Error from respond: $output");

147 return 0;

148 }

30 #

31 # 1.0 - Initial version

32 # 1.1 - Avoid leaving zombie ratbox-respond processes around

33 #

34 #####################

122 waitpid $pid, 0;

123

124 if($output =~ /^Error:/)

125 {

126 Xchat::print("ratbox-challenge: $output\n");

34 if ( !defined $child ) {

35 $conn->close;

36 $proxy->log( HTTP::Proxy::ERROR, "PROCESS", "Cannot start" );

37 next;

38 }

63 # EOLOOP

64 kill INT => @$kids;

65 $self->reap_zombies while @$kids;

66 }

67

75

76 # private reaper sub

77 sub reap_zombies {

78 my $self = shift;

79 my $kids = $self->kids;

7 {

8

9 my($error,$answer)=('','');

10 my ($pid, $sel);

11 my @handles = my ($fh_midish_write, $fh_midish_read, $fh_midish_error) = map{ IO::Handle->new() } 1..3;

16 chomp $executable;

17 $executable or say("Midish not found!"), return;

18 $pid = open3($fh_midish_write, $fh_midish_read, $fh_midish_error,"$executable -v")

19 or warn "Midish failed to start!";

20

21 $sel = IO::Select->new();

22 $sel->add($fh_midish_read);

23 $sel->add($fh_midish_error);

24 midish_command( qq(print "Midish is ready.") );

25 }

11 use DSMLLDAP;

12

13 sub zombie_reaper {

14 while (waitpid(-1, WNOHANG) > 0)

15 { }

16 $SIG{CHLD} = \&zombie_reaper;

17 }

18 $SIG{CHLD} = \&zombie_reaper;

70

71 if ($r->method eq 'GET') {

72 $httpd->send_error(RC_FORBIDDEN);

73 }

74 elsif ($r->method eq 'POST') {

8 # keeping an otherwise unused filesystem in use

9

10 # Double-fork to avoid leaving a zombie process behind

11 exit if (fork());

12 exit if (fork());

30

31 if ($log =~ /(err|fatal)/i) {

32 $priority = "error";

33 }

34 elsif ($log =~ /warning/i) {

8 #

9 # --overwrite: overwrite output file (only for testing!)

10 # --zombie: use program knowing it doesnt work

11

12 # TODO: MAYBE make zombie a global option in bclib.pl

14 require "/usr/local/lib/bclib.pl";

15

16 unless ($globopts{zombie}) {

17 die "DO NOT USE; Perl 32767 char regexp error breaks this program";

57 1;

58 } or do {

59 my $err = $@ || "(zombie error)";

60 warn "[Jabbot::Core][ERROR][plugin=${plugin_name}] $err";

52 #my $pid = open3(\*WRITE, \*READ,\*ERROR,"/bin/bash");

53 my $iou_pid = open3(\*WRITE, \*READ,\*ERROR,"cd $path; $image @ARGV");

54 #if \*ERROR is false, STDERR is sent to STDOUT

58 my $selwrite = new IO::Select();

59 $selread->add(\*READ);

60 $selerror->add(\*ERROR);

61

62

80 #see which filehandles have output

81 if($selread->can_read(0)){print "ready->read\n"}

82 if($selerror->can_read(0)){print "ready->error\n"}

83

84 #get any error from bc

85 sysread(ERROR,$error,4096) if $selerror->can_read(0);

86 if($error){print "\e[1;31m ERROR-> $error \e[0m \n"}

87

88 #get the answer from bc

31 my ($i, $frame);

32

33 LOG('error', "DIE-ing with message [$_[0]]");

34 LOG('error', 'stack trace:');

37 $frame = join(':', caller($i));

38 last unless $frame;

39 LOG('error', $frame);

40 }

41 exit(1);

71 sub REAPER

72 {

73 wait; # avoid the zombie

74 die "Shutting down.";

75 }

142 my $job = shift;

143 my $ret = {

144 error => 0,

145 };

146

164 };

165 if ( $@ ) {

166 $ret->{error} = 1;

167 $ret->{errorstr} = $@;

173 };

174 if ( $@ ) {

175 $ret->{error} = 1;

176 $ret->{errorstr} = $@;

180 if ( $@ ) {

181 CloudForecast::Log->warn("ledge failed: $@");

182 $ret->{error} = 1;

183 $ret->{errorstr} = $@;

2 use parent 'Games::Zumbis::L10N';

3 %Lexicon = (

4 'Erro carregando a fonte' => 'Error loading font',

5 'Aperte 1 para Heroi, 2 para Heroina ou enter para continuar!' => 'Press 1 for Hero, 2 for Heroin, or Enter to continue!',

6 'Voce sobreviveu por [_1] segundos!' => 'You survived for [_1] seconds!',

7 'E matou [quant,_1,zumbi]!' => 'And killed [quant,_1,zombie]!',

8 'Mortes:' => 'Kills:',

9 'segundos' => 'seconds',