コード例 #1
0
ファイル: mail.c プロジェクト: nhanh0/hah
int sendmail (const char *to,
              const char *subject,
              const char *body) 
{          
  CURL *curl;
  CURLcode res = CURLE_FAILED_INIT;
  struct curl_slist *recipients = NULL;
  struct upload_status upload_ctx;
 
  upload_ctx.lines_read = 0;
 
  curl = curl_easy_init();
  if (curl) {
    /* From & To must include '<>' */
    payload_text[0] = strdup_printf ("To: <%s>\n", to);
    payload_text[1] = strdup_printf ("From: <%s> (%s)\n", smtp_username, fullname);
    payload_text[2] = strdup_printf ("Subject: %s\n", subject);
    /* empty line to divide headers from body, see RFC5322 */
    payload_text[3] = "\n";
    payload_text[4] = strdup_printf ("%s\n", body);
    payload_text[5] = NULL;
 
    curl_easy_setopt(curl, CURLOPT_URL, smtp_server);
 
    curl_easy_setopt(curl, CURLOPT_USE_SSL, CURLUSESSL_ALL);
 
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
 
    curl_easy_setopt(curl, CURLOPT_USERNAME, smtp_username);
    curl_easy_setopt(curl, CURLOPT_PASSWORD, smtp_password);
 
    /* value for envelope reverse-path */
    curl_easy_setopt(curl, CURLOPT_MAIL_FROM, smtp_username);
 
    recipients = curl_slist_append(recipients, to);
    curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
 
    curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
    curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
 
    /* Since the traffic will be encrypted, it is very useful
    * to turn on debug information within libcurl to see what 
    * is happening during the transfer.
    */
    curl_easy_setopt(curl, CURLOPT_VERBOSE, 0);
 
    res = curl_easy_perform(curl);
 
    curl_slist_free_all(recipients);
    curl_easy_cleanup(curl);
 
    free (payload_text[0]);
    free (payload_text[1]);
    free (payload_text[2]);
    free (payload_text[4]);
  }
 
  return res;
}
コード例 #2
0
ファイル: output.c プロジェクト: BackupTheBerlios/ilenia-svn
void info(char *name, int options)
{
	char *reponame, *path, *pkgfile_path;
	struct repolist *repo;
	pkglist *p;
	reponame = pkglist_get_newer_favorite(name, options);
	if (reponame == NULL)
		error("%s not found!", name);
	repo = repolist_find(reponame, ilenia_repos);
	p = pkglist_select_from_repo(repo->name, ilenia_ports);
	p = pkglist_find(name, p);
	
	path = strdup_printf("%s/%s/%s", repo->path, repo->name, name);
	pkgfile_path = strdup_printf("%s/%s/%s/Pkgfile", repo->path, repo->name, name);

	FILE *f;
	f = fopen(pkgfile_path, "r");
	if(!f)
		exit(1);

	printf("Name: %s\nVersion: %s\n", p->name, p->version);
	char *line = NULL;
	size_t n;
	int nread;

	while((nread = getline(&line, &n, f)) > 0) {
		char *_line = strdup(line);
		trim(_line);
		if(*_line != '#')
			continue;
		_line++;
		trim(_line);
		while(strstr(_line, "  "))
			strreplaceall(_line, "  ", " ");
		printf("%s\n", _line);
		free(_line);
	}
	
	free(line);
	fclose(f);

	printf("Repository: %s\n", repo->name);
	printf("Path: %s\n", path);
	printf("Installed: %s\n", (pkglist_exists(p->name, ilenia_pkgs) ==
				   EXIT_SUCCESS) ? "yes" : "no");
	printf("README: %s\n", (is_file(path, "README") == EXIT_SUCCESS) ? "yes"
	       : "no");
	printf("pre-install: %s\n", (is_file(path, "pre-install") ==
				     EXIT_SUCCESS) ? "yes" : "no");
	printf("post-install: %s\n", (is_file(path, "post-install") ==
				      EXIT_SUCCESS) ? "yes" : "no");
	free(pkgfile_path);
	free(path);
}
コード例 #3
0
ファイル: ui.c プロジェクト: jens-na/abook-call
int
statusline_askchoice(const char *msg, const char *choices, short dflt)
{
    char *s;
    int ch;

    assert((dflt >= 0) && (dflt <= strlen(choices)));

    if(dflt) {
        s = strdup_printf("%s [%c]", msg, choices[dflt - 1]);
        statusline_addhlstr(s);
        free(s);
    } else
        statusline_addhlstr(msg);

    while(1)
    {
        ch = tolower(getch());

        if(ch == 7) /* ctrl+G */
            return 0;

        if(dflt && (ch == '\r')) /* default choice */
            return dflt;

        if((s = strchr(choices, ch)))
            return (s - choices + 1);
    }
}
コード例 #4
0
ファイル: pwd.c プロジェクト: KrieghofGames/mediafire-fuse
int mfshell_cmd_pwd(mfshell * mfshell, int argc, char *const argv[])
{
    (void)argv;
    const char     *folder_name;
    char           *folder_name_tmp = NULL;

    if (mfshell == NULL)
        return -1;
    if (mfshell->folder_curr == NULL)
        return -1;

    if (argc != 1) {
        fprintf(stderr, "Invalid number of arguments\n");
        return -1;
    }

    folder_name = folder_get_name(mfshell->folder_curr);
    if (folder_name[0] == '\0')
        return -1;

    folder_name_tmp = strdup_printf("< %s >", folder_name);

    printf("%-15.13s   %-50.50s\n\r",
           folder_get_key(mfshell->folder_curr), folder_name_tmp);

    free(folder_name_tmp);

    return 0;
}
コード例 #5
0
ファイル: ui.c プロジェクト: jens-na/abook-call
void
ui_print_number_of_items()
{
    char *str = strdup_printf("     " "|%3d/%3d",
                              selected_items(), db_n_items());

    mvaddstr(0, COLS-strlen(str), str);

    free(str);
}
コード例 #6
0
ファイル: ui.c プロジェクト: jens-na/abook-call
void
ui_read_database()
{
    char *msg;

    if(!list_is_empty()) {
        msg = strdup_printf(_("Your current data will be lost - "
                              "Press '%c' to continue"),
                            *(S_("keybinding for yes|y")));
        if(!statusline_ask_boolean(msg, FALSE)) {
            free(msg);
            return;
        }
        free(msg);
    }

    load_database(datafile);
    refresh_list();
}
コード例 #7
0
ファイル: filter.c プロジェクト: esseks/rmlint
/* It's a bit slow, because it has to call fork() internally */
static int check_binary_to_be_stripped(const char *path)
{
    FILE *pipe = NULL;
    int bytes = 0;
    char dummy_buf = 0,
         * cmd = NULL,
           * escaped = NULL;
    if(path == NULL)
    {
        return 0;
    }
    /* Escape ' so the shell does not get confused */
    escaped = strsubs(path,"'","'\"'\"'");
    /* The command we're using */
    cmd = strdup_printf("file '%s' | grep 'not stripped'", escaped);
    if(escaped)
    {
        free(escaped);
    }
    /* Pipe  */
    pipe = popen(cmd,"re");
    if(pipe == NULL)
    {
        return 0;
    }
    /* If one byte can be read, the file is a nonstripped binary */
    bytes = fread(&dummy_buf, sizeof(char), 1, pipe);
    /* close pipe */
    pclose(pipe);
    /* clean up */
    if(cmd)
    {
        free(cmd);
    }
    if(bytes)
    {
        return 1;
    }
    /* not a nsb  */
    return 0;
}
コード例 #8
0
ファイル: channels.cpp プロジェクト: carriercomm/AFKMud
/* Channel history. Records the last MAX_CHANHISTORY messages to channels which keep historys */
void update_channel_history( char_data * ch, mud_channel * channel, const string & argument, bool emote )
{
   int type = 0;
   const string newarg = add_percent( argument );

   chan_history *entry = new chan_history;

   if( !ch )
      entry->name = "System";
   else if( ch->isnpc() )
      entry->name = ch->short_descr;
   else
      entry->name = ch->name;

   strdup_printf( &entry->format, "   &R[%%s] &G%%s%s %s\r\n", emote ? "" : ":", newarg.c_str(  ) );

   entry->timestamp = current_time;

   if( ch && ch->has_aflag( AFF_INVISIBLE ) )
      type = 1;
   if( ch && ch->has_pcflag( PCFLAG_WIZINVIS ) )
   {
      type = 2;
      entry->invis = ch->pcdata->wizinvis;
   }
   entry->level = type;

   channel->history.push_back( entry );

   if( channel->history.size() > MAX_CHANHISTORY )
   {
      chan_history *oldentry = channel->history.front();

      channel->history.pop_front();
      deleteptr( oldentry );
   }
}
コード例 #9
0
int
upload_filedrop(CURL *curl_handle, char *api_root, char *endpoint,
                char *filepath, char *filedrop)
{
    FILE                *fh = NULL;
    struct curl_slist   *custom_headers = NULL;
    uint64_t            l_file_size;
    int                 retval;
    char                *url;
    char                *api_call;
    double              upload_speed;
    double              upload_time;
    char                *tmpstr = NULL;

    fprintf(stderr, "[II] opening %s\n", filepath);

    fh = fopen(filepath, "r");

    if(fh == NULL)
    {
        fprintf(stderr, "[EE] couldn't open specified file!\n");
        return -1;
    }

    // get the size of the file and then rewind
    retval = fseek(fh, 0, SEEK_END);
    l_file_size = ftell(fh);
    rewind(fh);

    curl_handle = curl_init_set(curl_handle);

    url = strdup_printf("%s%s", api_root, endpoint);

    api_call = strdup_printf("%s?action_on_duplicate=replace"
                                "&filedrop_key=%s",
                                 url, filedrop);

    custom_headers = curl_slist_append(custom_headers,
                    "Content-Type: application/octet-stream");

    custom_headers = curl_slist_append(custom_headers,
                    "Expect:");

    tmpstr = strdup_printf("x-filesize: %zd", l_file_size);
    custom_headers = curl_slist_append(custom_headers, tmpstr);
    free(tmpstr);

    tmpstr = strdup_printf("x-filename: %s", filepath);
    custom_headers = curl_slist_append(custom_headers, tmpstr);
    free(tmpstr);

    curl_easy_setopt(curl_handle, CURLOPT_POST, 1);
    curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, custom_headers);
    curl_easy_setopt(curl_handle, CURLOPT_URL, api_call);
    curl_easy_setopt(curl_handle, CURLOPT_READFUNCTION,
                     http_read_file_cb);
    curl_easy_setopt(curl_handle, CURLOPT_READDATA, (void *)fh);
    curl_easy_setopt(curl_handle, CURLOPT_POSTFIELDSIZE, l_file_size);
    curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, 1L);

    retval = curl_easy_perform(curl_handle);

    curl_easy_getinfo(curl_handle, CURLINFO_SPEED_UPLOAD, &upload_speed);
    curl_easy_getinfo(curl_handle, CURLINFO_TOTAL_TIME, &upload_time);

    fprintf(stderr, "Speed: %.3f bytes/sec during %.3f seconds\n",
            upload_speed, upload_time);

    curl_slist_free_all(custom_headers);
    custom_headers = NULL;

    fclose(fh);

    return 0;
}
コード例 #10
0
static int
_eXosip_retry_with_auth (eXosip_dialog_t * jd, osip_transaction_t ** ptr,
                         int *retry)
{
  osip_transaction_t *out_tr = NULL;
  osip_transaction_t *tr = NULL;
  osip_message_t *msg = NULL;
  osip_event_t *sipevent;
  jinfo_t *ji = NULL;

  int cseq;
  osip_via_t *via;
  int i;

  if (!ptr)
    return -1;

  if (jd != NULL)
    {
      if (jd->d_out_trs == NULL)
        return -1;
    }

  out_tr = *ptr;

  if (out_tr == NULL
      || out_tr->orig_request == NULL || out_tr->last_response == NULL)
    return -1;

  if (retry && (*retry >= 3))
    return -1;

  osip_message_clone (out_tr->orig_request, &msg);
  if (msg == NULL)
    {
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: could not clone msg for authentication\n"));
      return -1;
    }

  via = (osip_via_t *) osip_list_get (&msg->vias, 0);
  if (via == NULL || msg->cseq == NULL || msg->cseq->number == NULL)
    {
      osip_message_free (msg);
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: missing via or cseq header\n"));
      return -1;
    }

  /* increment cseq */
  cseq = atoi (msg->cseq->number);
  osip_free (msg->cseq->number);
  msg->cseq->number = strdup_printf ("%i", cseq + 1);
  if (jd != NULL && jd->d_dialog != NULL)
    {
      jd->d_dialog->local_cseq++;
    }

  i = eXosip_update_top_via(msg);
  if (i!=0)
    {
      osip_message_free (msg);
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: unsupported protocol\n"));
      return -1;
    }

  if (eXosip_add_authentication_information (msg, out_tr->last_response) < 0)
    {
      osip_message_free (msg);
      return -1;
    }

  osip_message_force_update (msg);

  if (MSG_IS_INVITE (msg))
    i = _eXosip_transaction_init (&tr, ICT, eXosip.j_osip, msg);
  else
    i = _eXosip_transaction_init (&tr, NICT, eXosip.j_osip, msg);

  if (i != 0)
    {
      osip_message_free (msg);
      return -1;
    }

  /* replace with the new tr */
  if (MSG_IS_PUBLISH(msg))
    {
      /* old transaction is put in the garbage list */
      osip_list_add (eXosip.j_transactions, out_tr, 0);
      /* new transaction is put in the publish context */
      *ptr = tr;
    }
  else
    osip_list_add (eXosip.j_transactions, tr, 0);

  sipevent = osip_new_outgoing_sipmessage (msg);

  ji = osip_transaction_get_your_instance (out_tr);

  osip_transaction_set_your_instance (out_tr, NULL);
  osip_transaction_set_your_instance (tr, ji);
  osip_transaction_add_event (tr, sipevent);

  if (retry)
    (*retry)++;

  eXosip_update ();             /* fixed? */
  __eXosip_wakeup ();
  return 0;
}
コード例 #11
0
int
_eXosip_call_retry_request (eXosip_call_t * jc,
                            eXosip_dialog_t * jd, osip_transaction_t * out_tr)
{
  osip_transaction_t *tr = NULL;
  osip_message_t *msg = NULL;
  osip_event_t *sipevent;

  int cseq;
  osip_via_t *via;
  osip_contact_t *co;
  int pos;
  int i;
  int protocol = IPPROTO_UDP;

  if (jc == NULL)
    return OSIP_BADPARAMETER;
  if (jd != NULL)
    {
      if (jd->d_out_trs == NULL)
        return OSIP_BADPARAMETER;
    }
  if (out_tr == NULL
      || out_tr->orig_request == NULL || out_tr->last_response == NULL)
    return OSIP_BADPARAMETER;

  i = osip_message_clone (out_tr->orig_request, &msg);
  if (i != 0)
    {
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: could not clone msg for authentication\n"));
      return i;
    }

  via = (osip_via_t *) osip_list_get (&msg->vias, 0);
  if (via == NULL || msg->cseq == NULL || msg->cseq->number == NULL)
    {
      osip_message_free (msg);
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: missing via or cseq header\n"));
      return OSIP_SYNTAXERROR;
    }

  if (MSG_IS_STATUS_3XX (out_tr->last_response))
    {
      co = NULL;
      pos = 0;
      while (!osip_list_eol (&out_tr->last_response->contacts, pos))
        {
          co =
            (osip_contact_t *) osip_list_get (&out_tr->last_response->contacts,
                                              pos);
          if (co != NULL && co->url != NULL)
            {
              /* check tranport? Only allow UDP, right now */
              osip_uri_param_t *u_param;
              int pos2;

              u_param = NULL;
              pos2 = 0;
              while (!osip_list_eol (&co->url->url_params, pos2))
                {
                  u_param =
                    (osip_uri_param_t *) osip_list_get (&co->url->url_params,
                                                        pos2);
                  if (u_param == NULL || u_param->gname == NULL
                      || u_param->gvalue == NULL)
                    {
                      u_param = NULL;
                      /* skip */
                  } else if (0 == osip_strcasecmp (u_param->gname, "transport"))
                    {
                      if (0 == osip_strcasecmp (u_param->gvalue, "udp"))
                        {
                          u_param = NULL;
                          protocol = IPPROTO_UDP;
                          break;        /* ok */
                      } else if (0 == osip_strcasecmp (u_param->gvalue, "tcp"))
                        {
                          protocol = IPPROTO_TCP;
                          u_param = NULL;
                        }
                      break;
                    }
                  pos2++;
                }

              if (u_param == NULL || u_param->gname == NULL
                  || u_param->gvalue == NULL)
                {
                  break;        /* default is udp! */
                }
            }
          pos++;
          co = NULL;
        }

      if (co == NULL || co->url == NULL)
        {
          osip_message_free (msg);
          OSIP_TRACE (osip_trace
                      (__FILE__, __LINE__, OSIP_ERROR, NULL,
                       "eXosip: contact header\n"));
          return OSIP_SYNTAXERROR;
        }

      /* TODO:
         remove extra parameter from new request-uri
         check usual parameter like "transport"
       */

      if (msg->req_uri != NULL && msg->req_uri->host != NULL
          && co->url->host != NULL
          && 0 == osip_strcasecmp (co->url->host, msg->req_uri->host))
        {
          osip_uri_param_t *maddr_param = NULL;
          osip_uri_uparam_get_byname (co->url, "maddr", &maddr_param);
          if (maddr_param != NULL && maddr_param->gvalue != NULL)
            {
              /* This is a redirect server, the route should probably be removed? */
              osip_route_t *route = NULL;
              osip_generic_param_t *tag = NULL;
              osip_message_get_route (msg, 0, &route);
              if (route != NULL)
                {
                  osip_to_get_tag (msg->to, &tag);
                  if (tag == NULL && route != NULL && route->url != NULL)
                    {
                      osip_list_remove (&msg->routes, 0);
                      osip_route_free (route);
                    }
                }
            }
        }

      /* replace request-uri with NEW contact address */
      osip_uri_free (msg->req_uri);
      msg->req_uri = NULL;
      osip_uri_clone (co->url, &msg->req_uri);

      /* support for diversions headers/draft! */
      {
        int count = 0;
        pos = 0;
        while (!osip_list_eol (&out_tr->last_response->headers, pos))
          {
            osip_header_t *copy = NULL;
            osip_header_t *head =
              osip_list_get (&out_tr->last_response->headers, pos);
            if (head != NULL && 0 == osip_strcasecmp (head->hname, "diversion"))
              {
                i = osip_header_clone (head, &copy);
                if (i == 0)
                  {
                    osip_list_add (&msg->headers, copy, count);
                    count++;
                  }
              }
            pos++;
          }
      }

    }
  /* remove all previous authentication headers */
  osip_list_special_free (&msg->authorizations,
                          (void *(*)(void *)) &osip_authorization_free);
  osip_list_special_free (&msg->proxy_authorizations,
                          (void *(*)(void *)) &osip_proxy_authorization_free);

  /* increment cseq */
  cseq = atoi (msg->cseq->number);
  osip_free (msg->cseq->number);
  msg->cseq->number = strdup_printf ("%i", cseq + 1);
  if (jd != NULL && jd->d_dialog != NULL)
    {
      jd->d_dialog->local_cseq++;
    }

  i = eXosip_update_top_via (msg);
  if (i != 0)
    {
      osip_message_free (msg);
      return i;
    }

  if (out_tr->last_response->status_code == 401
      || out_tr->last_response->status_code == 407)
    eXosip_add_authentication_information (msg, out_tr->last_response);
  else
    eXosip_add_authentication_information (msg, NULL);
  osip_message_force_update (msg);

  if (0 != osip_strcasecmp (msg->sip_method, "INVITE"))
    {
      i = _eXosip_transaction_init (&tr, NICT, eXosip.j_osip, msg);
  } else
    {
      i = _eXosip_transaction_init (&tr, ICT, eXosip.j_osip, msg);
    }

  if (i != 0)
    {
      osip_message_free (msg);
      return i;
    }

  if (out_tr == jc->c_out_tr)
    {
      /* replace with the new tr */
      osip_list_add (&eXosip.j_transactions, jc->c_out_tr, 0);
      jc->c_out_tr = tr;

      /* fix dialog issue */
      if (jd != NULL)
        {
          REMOVE_ELEMENT (jc->c_dialogs, jd);
          eXosip_dialog_free (jd);
          jd = NULL;
        }
  } else
    {
      /* add the new tr for the current dialog */
      osip_list_add (jd->d_out_trs, tr, 0);
    }

  sipevent = osip_new_outgoing_sipmessage (msg);

#ifndef MINISIZE
  osip_transaction_set_your_instance (tr, __eXosip_new_jinfo (jc, jd, NULL, NULL));
#else
  osip_transaction_set_your_instance (tr, __eXosip_new_jinfo (jc, jd));
#endif
  osip_transaction_add_event (tr, sipevent);

  eXosip_update ();             /* fixed? */
  __eXosip_wakeup ();
  return OSIP_SUCCESS;
}
コード例 #12
0
int
_eXosip_insubscription_send_request_with_credential (eXosip_notify_t * jn,
        eXosip_dialog_t * jd,
        osip_transaction_t * out_tr)
{
    osip_transaction_t *tr = NULL;
    osip_message_t *msg = NULL;
    osip_event_t *sipevent;

    char locip[256];
    int cseq;
    char tmp[256];
    osip_via_t *via;
    int i;

    if (jn == NULL)
        return -1;
    if (jd != NULL)
    {
        if (jd->d_out_trs == NULL)
            return -1;
    }

    if (out_tr == NULL)
    {
        out_tr = eXosip_find_last_out_notify (jn, jd);
    }

    if (out_tr == NULL
            || out_tr->orig_request == NULL || out_tr->last_response == NULL)
        return -1;

    osip_message_clone (out_tr->orig_request, &msg);
    if (msg == NULL)
    {
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_ERROR, NULL,
                     "eXosip: could not clone msg for authentication\n"));
        return -1;
    }

    via = (osip_via_t *) osip_list_get (msg->vias, 0);
    if (via == NULL || msg->cseq == NULL || msg->cseq->number == NULL)
    {
        osip_message_free (msg);
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_ERROR, NULL,
                     "eXosip: missing via or cseq header\n"));
        return -1;
    }

    /* increment cseq */
    cseq = atoi (msg->cseq->number);
    osip_free (msg->cseq->number);
    msg->cseq->number = strdup_printf ("%i", cseq + 1);
    if (jd != NULL && jd->d_dialog != NULL)
    {
        jd->d_dialog->local_cseq++;
    }

    osip_list_remove (msg->vias, 0);
    osip_via_free (via);

    i = _eXosip_find_protocol (out_tr->orig_request);
    if (i == IPPROTO_UDP)
    {
        eXosip_guess_ip_for_via (eXosip.net_interfaces[0].net_ip_family, locip,
                                 sizeof (locip));
        if (eXosip.net_interfaces[0].net_ip_family == AF_INET6)
            snprintf (tmp, 256, "SIP/2.0/UDP [%s]:%s;branch=z9hG4bK%u",
                      locip, eXosip.net_interfaces[0].net_port,
                      via_branch_new_random ());
        else
            snprintf (tmp, 256, "SIP/2.0/UDP %s:%s;rport;branch=z9hG4bK%u",
                      locip, eXosip.net_interfaces[0].net_port,
                      via_branch_new_random ());
    } else if (i == IPPROTO_TCP)
    {
        eXosip_guess_ip_for_via (eXosip.net_interfaces[1].net_ip_family, locip,
                                 sizeof (locip));
        if (eXosip.net_interfaces[1].net_ip_family == AF_INET6)
            snprintf (tmp, 256, "SIP/2.0/TCP [%s]:%s;branch=z9hG4bK%u",
                      locip, eXosip.net_interfaces[1].net_port,
                      via_branch_new_random ());
        else
            snprintf (tmp, 256, "SIP/2.0/TCP %s:%s;rport;branch=z9hG4bK%u",
                      locip, eXosip.net_interfaces[1].net_port,
                      via_branch_new_random ());
    } else
    {
        /* tls? */
        osip_message_free (msg);
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_ERROR, NULL,
                     "eXosip: unsupported protocol\n"));
        return -1;
    }

    osip_via_init (&via);
    osip_via_parse (via, tmp);
    osip_list_add (msg->vias, via, 0);

    eXosip_add_authentication_information (msg, out_tr->last_response);
    osip_message_force_update (msg);

    i = osip_transaction_init (&tr, NICT, eXosip.j_osip, msg);

    if (i != 0)
    {
        osip_message_free (msg);
        return -1;
    }

    /* add the new tr for the current dialog */
    osip_list_add (jd->d_out_trs, tr, 0);

    sipevent = osip_new_outgoing_sipmessage (msg);

    osip_transaction_set_your_instance (tr, __eXosip_new_jinfo (NULL, jd, NULL, jn));
    osip_transaction_add_event (tr, sipevent);

    eXosip_update ();             /* fixed? */
    __eXosip_wakeup ();
    return 0;
}
コード例 #13
0
ファイル: filter.c プロジェクト: esseks/rmlint
/*
 * Callbock from nftw()
 * If the file given from nftw by "path":
 * - is a directory: recurs into it and catch the files there,
 *  as long the depth doesnt get bigger than max_depth and contains the pattern  cmp_pattern
 * - a file: Push it back to the list, if it has "cmp_pattern" in it. (if --regex was given)
 * If the user interrupts, nftw() stops, and the program will do it'S magic.
 *
 * Not many comments, because man page of nftw will explain everything you'll need to understand
 *
 * Appendum: rmlint uses the inode to sort the contents before doing any I/O to speed up things.
 *           This is nevertheless limited to Unix filesystems like ext*, reiserfs.. (might work in MacOSX - don't know)
 *           If someone likes to port this to Windows he would to replace the inode number by the MFT entry point, or simply disable it
 *           I personally don't have a win comp and won't port it, as I don't found many users knowing what that black window with white
 *           white letters can do ;-)
 */
static int eval_file(const char *path, const struct stat *ptr, int flag, struct FTW *ftwbuf)
{
    if(set->depth && ftwbuf->level > set->depth)
    {
        /* Do not recurse in this subdir */
        return FTW_SKIP_SIBLINGS;
    }
    if(iAbort)
    {
        return FTW_STOP;
    }
    if(flag == FTW_SLN)
    {
        list_append(path, 0,ptr->st_dev,ptr->st_ino,TYPE_BLNK);
        return FTW_CONTINUE;
    }
    if(path)
    {
        if(!dir_done)
        {
            char *orig_path = set->paths[get_cpindex()];
            size_t orig_path_len = strlen(set->paths[get_cpindex()]);
            if(orig_path[orig_path_len - 1] == '/') {
                orig_path_len -= 1;
            }
            if(!strncmp(set->paths[get_cpindex()], path, orig_path_len))
            {
                dir_done = true;
                return FTW_CONTINUE;
            }
        }
        if(flag == FTW_F &&
                (set->minsize <= ptr->st_size || set->minsize < 0) &&
                (set->maxsize >= ptr->st_size || set->maxsize < 0))
        {
            if(regfilter(path, set->fpattern))
            {
                return FTW_CONTINUE;
            }
            if(junkinstr(rmlint_basename(path)))
            {
                list_append(path, 0,ptr->st_dev,ptr->st_ino,TYPE_JNK_FILENAME);
                if(set->collide)
                {
                    return FTW_CONTINUE;
                }
            }
            if(set->findbadids)
            {
                bool has_gid, has_uid;
                if(userlist_contains(global_ug_list,ptr->st_uid,ptr->st_gid,&has_uid,&has_gid) == false)
                {
                    if(has_gid == false)
                        list_append(path,0,ptr->st_dev,ptr->st_ino,TYPE_BADGID);
                    if(has_uid == false)
                        list_append(path,0,ptr->st_dev,ptr->st_ino,TYPE_BADUID);

                    if(set->collide)
                    {
                        return FTW_CONTINUE;
                    }
                }
            }
            if(set->nonstripped)
            {
                if(check_binary_to_be_stripped(path))
                {
                    list_append(path, 0,ptr->st_dev,ptr->st_ino,TYPE_NBIN);
                    if(set->collide)
                    {
                        return FTW_CONTINUE;
                    }
                }
            }
            if(set->doldtmp)
            {
                /* This checks only for *~ and .*.swp */
                size_t len = strlen(path);
                if(path[len-1] == '~' || (len>3&&path[len-1] == 'p'&&path[len-2] == 'w'&&path[len-3] == 's'&&path[len-4] == '.'))
                {
                    char *cpy = NULL;
                    struct stat stat_buf;
                    if(path[len - 1] == '~')
                    {
                        cpy = strndup(path,len-1);
                    }
                    else
                    {
                        char * p = strrchr(path,'/');
                        size_t p_len = p-path;
                        char * front = alloca(p_len+1);
                        memset(front, '\0', p_len+1);
                        strncpy(front, path, p_len);
                        cpy = strdup_printf("%s/%s",front,p+2);
                        cpy[strlen(cpy)-4] = 0;
                    }
                    if(!stat(cpy, &stat_buf))
                    {
                        if(ptr->st_mtime - stat_buf.st_mtime >= set->oldtmpdata)
                        {
                            list_append(path, 0,ptr->st_dev,ptr->st_ino,TYPE_OTMP);
                        }
                    }
                    if(cpy)
                    {
                        free(cpy);
                    }
                    if(set->collide)
                    {
                        return FTW_CONTINUE;
                    }
                }
            }
            /* Check this to be a valid file and NOT a blockfile (reading /dev/null does funny things) */
            if(flag == FTW_F && !(S_ISCHR(ptr->st_mode) || S_ISBLK(ptr->st_mode)) && (set->listemptyfiles || ptr->st_size != 0))
            {
                if(!access(path,R_OK))
                {
                    if(set->ignore_hidden)
                    {
                        char *base = rmlint_basename(path);
                        if(*base != '.')
                        {
                            dircount++;
                            list_append(path, ptr->st_size,ptr->st_dev,ptr->st_ino,1);
                        }
                    }
                    else
                    {
                        dircount++;
                        list_append(path, ptr->st_size,ptr->st_dev,ptr->st_ino,1);
                    }
                }
                return FTW_CONTINUE;
            }
        }
        if(flag == FTW_D)
        {
            if(regfilter(path, set->dpattern) && dir_done)
            {
                return FTW_SKIP_SUBTREE;
            }
            if(junkinstr(rmlint_basename(path)))
            {
                list_append(path, 0,ptr->st_dev,ptr->st_ino,TYPE_JNK_DIRNAME);
                if(set->collide)
                {
                    return FTW_SKIP_SUBTREE;
                }
            }
            if(set->findemptydirs)
            {
                int dir_counter = 0;
                DIR *dir_e = opendir(path);
                struct dirent *dir_p = NULL;
                if(dir_e)
                {
                    while((dir_p=readdir(dir_e)) && dir_counter < 2)
                    {
                        dir_counter++;
                    }
                    closedir(dir_e);
                    if(dir_counter == 2 && dir_p == NULL)
                    {
                        list_append(path, 0,ptr->st_dev,ptr->st_ino,TYPE_EDIR);
                        return FTW_SKIP_SUBTREE;
                    }
                }
            }
            if(set->ignore_hidden && path)
            {
                char *base = rmlint_basename(path);
                if(*base == '.' && dir_done)
                {
                    return FTW_SKIP_SUBTREE;
                }
            }
        }
    }
    return FTW_CONTINUE;
}
コード例 #14
0
ファイル: lsports.c プロジェクト: BackupTheBerlios/ilenia-svn
int parse_pkgfile(char *filename, char *repo)
{
	FILE *file;
	size_t n = 0;
	char *line = NULL;
	ssize_t nread;

	struct deplist *d = NULL;

	char *name = NULL, *version = NULL, *release = NULL;

	file = fopen(filename, "r");
	if (file == NULL)
		return (EXIT_FAILURE);

	while ((nread = getline(&line, &n, file)) != -1) {
		trim(line);
		if (line[0] == '#') {
			line = mid(line, 1, END);
			trim(line);

			if (strstr(line, "Depends") == NULL)
				continue;
			if (strstr(line, ":") == NULL)
				continue;

			line = strstr(line, ":");

			line = mid(line, 1, END);
			trim(line);
			d = deplist_from_deprow(line);
			line = NULL;

		} else if (strncmp(line, "name", 4) == 0)
			name = get_value(line, "name");
		else if (strncmp(line, "version", 7) == 0)
			version = get_value(line, "version");
		else if (strncmp(line, "release", 7) == 0)
			release = get_value(line, "release");
	}

	if (!(name && version && release))
		return (EXIT_FAILURE);

	version = sedchr(version, ' ', '_');

	char *dirname = filename;
	*(strrchr(dirname, '/')) = 0;
	dirname = strrchr(filename, '/');
	++dirname;

	if(strcmp(name, dirname))
		return EXIT_FAILURE;

	char *tmp = strdup_printf("%s %s-%s %s", name, version, release, repo);
	
	if(sscanf(tmp, "%s %s %s", name, version, repo)!=3) {
		free(tmp);
		return EXIT_FAILURE;
	}

	
	fprintf(cachefile, "%s", tmp);

	free(tmp);

	while (d != NULL) {
		fprintf(cachefile, " %s", d->name);
		d = d->next;
	}

	fprintf(cachefile, "\n");
	if (line)
		free(line);
	fclose(file);
	return (EXIT_SUCCESS);
}
コード例 #15
0
int
_eXosip_insubscription_send_request_with_credential (eXosip_notify_t * jn,
                                                     eXosip_dialog_t * jd,
                                                     osip_transaction_t * out_tr)
{
  osip_transaction_t *tr = NULL;
  osip_message_t *msg = NULL;
  osip_event_t *sipevent;

  int cseq;
  osip_via_t *via;
  int i;

  if (jn == NULL)
    return OSIP_BADPARAMETER;
  if (jd != NULL)
    {
      if (jd->d_out_trs == NULL)
        return OSIP_BADPARAMETER;
    }

  if (out_tr == NULL)
    {
      out_tr = eXosip_find_last_out_notify (jn, jd);
    }

  if (out_tr == NULL
      || out_tr->orig_request == NULL || out_tr->last_response == NULL)
    return OSIP_NOTFOUND;

  i = osip_message_clone (out_tr->orig_request, &msg);
  if (i != 0)
    {
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: could not clone msg for authentication\n"));
      return i;
    }

  via = (osip_via_t *) osip_list_get (&msg->vias, 0);
  if (via == NULL || msg->cseq == NULL || msg->cseq->number == NULL)
    {
      osip_message_free (msg);
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: missing via or cseq header\n"));
      return OSIP_SYNTAXERROR;
    }

  /* increment cseq */
  cseq = atoi (msg->cseq->number);
  osip_free (msg->cseq->number);
  msg->cseq->number = strdup_printf ("%i", cseq + 1);
  if (msg->cseq->number == NULL)
    {
      osip_message_free (msg);
      return OSIP_NOMEM;
    }

  if (jd != NULL && jd->d_dialog != NULL)
    {
      jd->d_dialog->local_cseq++;
    }

  i = eXosip_update_top_via (msg);
  if (i != 0)
    {
      osip_message_free (msg);
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: unsupported protocol\n"));
      return i;
    }

  if (out_tr->last_response->status_code == 401
      || out_tr->last_response->status_code == 407)
    eXosip_add_authentication_information (msg, out_tr->last_response);
  else
    eXosip_add_authentication_information (msg, NULL);

  osip_message_force_update (msg);

  i = _eXosip_transaction_init (&tr, NICT, eXosip.j_osip, msg);

  if (i != 0)
    {
      osip_message_free (msg);
      return i;
    }

  /* add the new tr for the current dialog */
  osip_list_add (jd->d_out_trs, tr, 0);

  sipevent = osip_new_outgoing_sipmessage (msg);

  osip_transaction_set_your_instance (tr, __eXosip_new_jinfo (NULL, jd, NULL, jn));
  osip_transaction_add_event (tr, sipevent);

  eXosip_update ();             /* fixed? */
  __eXosip_wakeup ();
  return OSIP_SUCCESS;
}