summaryrefslogtreecommitdiffstats
path: root/vppinfra/mkinstalldirs
blob: d2d5f21b611235316317197d3a32c2dff5897a6f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#! /bin/sh
# mkinstalldirs --- make directory hierarchy
# Author: Noah Friedman <friedman@prep.ai.mit.edu>
# Created: 1993-05-16
# Public domain

errstatus=0
dirmode=""

usage="\
Usage: mkinstalldirs [-h] [--help] [-m mode] dir ..."

# process command line arguments
while test $# -gt 0 ; do
  case $1 in
    -h | --help | --h*)         # -h for help
      echo "$usage" 1>&2
      exit 0
      ;;
    -m)                         # -m PERM arg
      shift
      test $# -eq 0 && { echo "$usage" 1>&2; exit 1; }
      dirmode=$1
      shift
      ;;
    --)                         # stop option processing
      shift
      break
      ;;
    -*)                         # unknown option
      echo "$usage" 1>&2
      exit 1
      ;;
    *)                          # first non-opt arg
      break
      ;;
  esac
done

for file
do
  if test -d "$file"; then
    shift
  else
    break
  fi
done

case $# in
  0) exit 0 ;;
esac

case $dirmode in
  '')
    if mkdir -p -- . 2>/dev/null; then
      echo "mkdir -p -- $*"
      exec mkdir -p -- "$@"
    fi
    ;;
  *)
    if mkdir -m "$dirmode" -p -- . 2>/dev/null; then
      echo "mkdir -m $dirmode -p -- $*"
      exec mkdir -m "$dirmode" -p -- "$@"
    fi
    ;;
esac

for file
do
  set fnord `echo ":$file" | sed -ne 's/^:\//#/;s/^://;s/\// /g;s/^#/\//;p'`
  shift

  pathcomp=
  for d
  do
    pathcomp="$pathcomp$d"
    case $pathcomp in
      -*) pathcomp=./$pathcomp ;;
    esac

    if test ! -d "$pathcomp"; then
      echo "mkdir $pathcomp"

      mkdir "$pathcomp" || lasterr=$?

      if test ! -d "$pathcomp"; then
  	errstatus=$lasterr
      else
  	if test ! -z "$dirmode"; then
	  echo "chmod $dirmode $pathcomp"
    	  lasterr=""
  	  chmod "$dirmode" "$pathcomp" || lasterr=$?

  	  if test ! -z "$lasterr"; then
  	    errstatus=$lasterr
  	  fi
  	fi
      fi
    fi

    pathcomp="$pathcomp/"
  done
done

exit $errstatus

# Local Variables:
# mode: shell-script
# sh-indentation: 2
# End:
# mkinstalldirs ends here
notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include <vlib/vlib.h> #include <vnet/pg/pg.h> #include <vnet/osi/osi.h> #include <vnet/ppp/ppp.h> #include <vnet/hdlc/hdlc.h> #include <vnet/llc/llc.h> #define foreach_osi_input_next \ _ (PUNT, "error-punt") \ _ (DROP, "error-drop") typedef enum { #define _(s,n) OSI_INPUT_NEXT_##s, foreach_osi_input_next #undef _ OSI_INPUT_N_NEXT, } osi_input_next_t; typedef struct { u8 packet_data[32]; } osi_input_trace_t; static u8 * format_osi_input_trace (u8 * s, va_list * va) { CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *); CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *); osi_input_trace_t *t = va_arg (*va, osi_input_trace_t *); s = format (s, "%U", format_osi_header, t->packet_data); return s; } static uword osi_input (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * from_frame) { osi_main_t *lm = &osi_main; u32 n_left_from, next_index, *from, *to_next; from = vlib_frame_vector_args (from_frame); n_left_from = from_frame->n_vectors; if (node->flags & VLIB_NODE_FLAG_TRACE) vlib_trace_frame_buffers_only (vm, node, from, n_left_from, sizeof (from[0]), sizeof (osi_input_trace_t)); next_index = node->cached_next_index; while (n_left_from > 0) { u32 n_left_to_next; vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 4 && n_left_to_next >= 2) { u32 bi0, bi1; vlib_buffer_t *b0, *b1; osi_header_t *h0, *h1; u8 next0, next1, enqueue_code; /* Prefetch next iteration. */ { vlib_buffer_t *b2, *b3; b2 = vlib_get_buffer (vm, from[2]); b3 = vlib_get_buffer (vm, from[3]); vlib_prefetch_buffer_header (b2, LOAD); vlib_prefetch_buffer_header (b3, LOAD); CLIB_PREFETCH (b2->data, sizeof (h0[0]), LOAD); CLIB_PREFETCH (b3->data, sizeof (h1[0]), LOAD); } bi0 = from[0]; bi1 = from[1]; to_next[0] = bi0; to_next[1] = bi1; from += 2; to_next += 2; n_left_to_next -= 2; n_left_from -= 2; b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); h0 = (void *) (b0->data + b0->current_data); h1 = (void *) (b1->data + b1->current_data); next0 = lm->input_next_by_protocol[h0->protocol]; next1 = lm->input_next_by_protocol[h1->protocol]; b0->error = node->errors[next0 == OSI_INPUT_NEXT_DROP ? OSI_ERROR_UNKNOWN_PROTOCOL : OSI_ERROR_NONE]; b1->error = node->errors[next1 == OSI_INPUT_NEXT_DROP ? OSI_ERROR_UNKNOWN_PROTOCOL : OSI_ERROR_NONE]; enqueue_code = (next0 != next_index) + 2 * (next1 != next_index); if (PREDICT_FALSE (enqueue_code != 0)) { switch (enqueue_code) { case 1: /* A B A */ to_next[-2] = bi1; to_next -= 1; n_left_to_next += 1; vlib_set_next_frame_buffer (vm, node, next0, bi0); break; case 2: /* A A B */ to_next -= 1; n_left_to_next += 1; vlib_set_next_frame_buffer (vm, node, next1, bi1); break; case 3: /* A B B or A B C */ to_next -= 2; n_left_to_next += 2; vlib_set_next_frame_buffer (vm, node, next0, bi0); vlib_set_next_frame_buffer (vm, node, next1, bi1); if (next0 == next1) { vlib_put_next_frame (vm, node, next_index, n_left_to_next); next_index = next1; vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); } } } } while (n_left_from > 0 && n_left_to_next > 0) { u32 bi0; vlib_buffer_t *b0; osi_header_t *h0; u8 next0; bi0 = from[0]; to_next[0] = bi0; from += 1; to_next += 1; n_left_from -= 1; n_left_to_next -= 1; b0 = vlib_get_buffer (vm, bi0); h0 = (void *) (b0->data + b0->current_data); next0 = lm->input_next_by_protocol[h0->protocol]; b0->error = node->errors[next0 == OSI_INPUT_NEXT_DROP ? OSI_ERROR_UNKNOWN_PROTOCOL : OSI_ERROR_NONE]; /* Sent packet to wrong next? */ if (PREDICT_FALSE (next0 != next_index)) { /* Return old frame; remove incorrectly enqueued packet. */ vlib_put_next_frame (vm, node, next_index, n_left_to_next + 1); /* Send to correct next. */ next_index = next0; vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); to_next[0] = bi0; to_next += 1; n_left_to_next -= 1; } } vlib_put_next_frame (vm, node, next_index, n_left_to_next); } return from_frame->n_vectors; } static char *osi_error_strings[] = { #define _(f,s) s, foreach_osi_error #undef _ }; /* *INDENT-OFF* */ VLIB_REGISTER_NODE (osi_input_node) = { .function = osi_input, .name = "osi-input", /* Takes a vector of packets. */ .vector_size = sizeof (u32), .n_errors = OSI_N_ERROR, .error_strings = osi_error_strings, .n_next_nodes = OSI_INPUT_N_NEXT, .next_nodes = { #define _(s,n) [OSI_INPUT_NEXT_##s] = n, foreach_osi_input_next #undef _ }, .format_buffer = format_osi_header_with_length, .format_trace = format_osi_input_trace, .unformat_buffer = unformat_osi_header, }; /* *INDENT-ON* */ static clib_error_t * osi_input_init (vlib_main_t * vm) { clib_error_t *error = 0; osi_main_t *lm = &osi_main; if ((error = vlib_call_init_function (vm, osi_init))) return error; osi_setup_node (vm, osi_input_node.index); { int i; for (i = 0; i < ARRAY_LEN (lm->input_next_by_protocol); i++) lm->input_next_by_protocol[i] = OSI_INPUT_NEXT_DROP; } ppp_register_input_protocol (vm, PPP_PROTOCOL_osi, osi_input_node.index); hdlc_register_input_protocol (vm, HDLC_PROTOCOL_osi, osi_input_node.index); llc_register_input_protocol (vm, LLC_PROTOCOL_osi_layer1, osi_input_node.index); llc_register_input_protocol (vm, LLC_PROTOCOL_osi_layer2, osi_input_node.index); llc_register_input_protocol (vm, LLC_PROTOCOL_osi_layer3, osi_input_node.index); llc_register_input_protocol (vm, LLC_PROTOCOL_osi_layer4, osi_input_node.index); llc_register_input_protocol (vm, LLC_PROTOCOL_osi_layer5, osi_input_node.index); return 0; } VLIB_INIT_FUNCTION (osi_input_init); void osi_register_input_protocol (osi_protocol_t protocol, u32 node_index) { osi_main_t *lm = &osi_main; vlib_main_t *vm = lm->vlib_main; osi_protocol_info_t *pi; { clib_error_t *error = vlib_call_init_function (vm, osi_input_init); if (error) clib_error_report (error); } pi = osi_get_protocol_info (lm, protocol); pi->node_index = node_index; pi->next_index = vlib_node_add_next (vm, osi_input_node.index, node_index); lm->input_next_by_protocol[protocol] = pi->next_index; } /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */