Development/Tutorials/KNewStuffSecure - Revision history

Neverendingo: Text replace - "" to ""

2011-06-29T20:52:26Z

Text replace - "</code>" to "</syntaxhighlight>"

Neverendingo: Text replace - "`" to ""`


2011-06-29T20:35:33Z
Text replace - "<code cppqt3>" to "<syntaxhighlight lang="cpp-qt">"

				
				
				
				
			
			← Older revision
			Revision as of 20:35, 29 June 2011
			
Line 20:
Line 20:
  == Downloading resources ==   == Downloading resources ==
  The first thing you must to is to subclass the {{class|KNewStuffSecure}} class and implement the installResource method, which is a pure virtual method in KNewStuffSecure. Here is an example of what you should put in a header file:   The first thing you must to is to subclass the {{class|KNewStuffSecure}} class and implement the installResource method, which is a pure virtual method in KNewStuffSecure. Here is an example of what you should put in a header file:
− <code cppqt3> + <syntaxhighlight lang="cpp-qt">
  #include <knewstuff/knewstuffsecure.h>   #include <knewstuff/knewstuffsecure.h>
    
Line 51:
Line 51:
  In the implementation file you have to process the {{path|data.tar.gz}} only, the rest is handled by KNewStuffSecure. If installing the resource means that you put the downloaded file(s) from {{path|data.tar.gz}} into a directory, the implementation of MyNewStuff looks like:   In the implementation file you have to process the {{path|data.tar.gz}} only, the rest is handled by KNewStuffSecure. If installing the resource means that you put the downloaded file(s) from {{path|data.tar.gz}} into a directory, the implementation of MyNewStuff looks like:
    
− <code cppqt3> + <syntaxhighlight lang="cpp-qt">
  void MyNewStuff::installResource()   void MyNewStuff::installResource()
  {   {
Line 80:
Line 80:
    
  Example:   Example:
− <code cppqt3> + <syntaxhighlight lang="cpp-qt">
  void MyApp::slotDownloadResource()   void MyApp::slotDownloadResource()
  {   {
Line 100:
Line 100:
    
  Example:   Example:
− <code cppqt3> + <syntaxhighlight lang="cpp-qt">
  void MyApp::slotUploadResource()   void MyApp::slotUploadResource()
  {   {



Tampakrap: add KDE 3 marker
2008-11-23T07:34:14Z
add KDE 3 marker

				
				
				
				
			
			← Older revision
			Revision as of 07:34, 23 November 2008
			
Line 1:
Line 1:
  {{Improve}}   {{Improve}}
  + {{KDE3}}
    
  == Resource sharing ==   == Resource sharing ==





Tampakrap: removed a wtf usage of a bool variable "ok"
2008-06-22T22:29:54Z
removed a wtf usage of a bool variable "ok"

				
				
				
				
			
			← Older revision
			Revision as of 22:29, 22 June 2008
			
Line 53:
Line 53:
  void MyNewStuff::installResource()   void MyNewStuff::installResource()
  {   {
−   bool ok = true;  
     KTar tar(m_tarName, "application/x-gzip" );      KTar tar(m_tarName, "application/x-gzip" );
     if (tar.open(IO_ReadOnly))      if (tar.open(IO_ReadOnly))
Line 62:
Line 61:
       tar.close();        tar.close();
     } else      } else
−     ok = false;  
−  
−   if (!ok)  
       KMessageBox::error(parentWidget(), i18n("There was an error with the        KMessageBox::error(parentWidget(), i18n("There was an error with the
       downloaded resource tarball file. Possible causes are damaged archive or        downloaded resource tarball file. Possible causes are damaged archive or



Pino: {{file}} -> {{path}}
2007-05-29T00:09:43Z
{{file}} -> {{path}}

				
				
				
				
			
			← Older revision
			Revision as of 00:09, 29 May 2007
			
Line 41:
Line 41:
  ! Filename !! Description   ! Filename !! Description
  |-   |-
− | {{file|data.tar.gz}} || another tarball containing the actual data to be installed. The name is not fixed, it can be anything like {{file|cards.tgz}}, {{file|greetings.tar.gz}} or whatever. + | {{path|data.tar.gz}} || another tarball containing the actual data to be installed. The name is not fixed, it can be anything like {{path|cards.tgz}}, {{path|greetings.tar.gz}} or whatever.
  |-   |-
− | signature || holds the signature for {{file|data.tar.gz}} + | signature || holds the signature for {{path|data.tar.gz}}
  |-   |-
− | md5sum || holds the MD5 sum for the {{file|data.tar.gz}} + | md5sum || holds the MD5 sum for the {{path|data.tar.gz}}
  |}   |}
    





Pino: {{file}} -> {{path}}
2007-05-29T00:00:21Z
{{file}} -> {{path}}

				
				
				
				
			
			← Older revision
			Revision as of 00:00, 29 May 2007
			
Line 12:
Line 12:
  == General information ==   == General information ==
    
− Using KNewStuff itself is quite simple, and I tried to make KNewStuffSecure not more complicated. The only extra requirement is to have <strong>gpg</strong> installed in your {{file|$PATH}}, and for uploading of course it is preferred if you already have a GPG key that you can use for resource signing. + Using KNewStuff itself is quite simple, and I tried to make KNewStuffSecure not more complicated. The only extra requirement is to have <strong>gpg</strong> installed in your {{path|$PATH}}, and for uploading of course it is preferred if you already have a GPG key that you can use for resource signing.
    
  As '''gpg''' is not a compilation time requirement, it is suggested that you check on application startup for its presence and warn the user what he misses without it. Of course the check is performed by KNewStuffSecure as well, but I find it muchnicer to check for runtime dependencies on startup.   As '''gpg''' is not a compilation time requirement, it is suggested that you check on application startup for its presence and warn the user what he misses without it. Of course the check is performed by KNewStuffSecure as well, but I find it muchnicer to check for runtime dependencies on startup.
Line 36:
Line 36:
  </code>   </code>
    
− In order to know what you should do in installResource() it is important to understand the structure of the resource you get via KNewStuffSecure. The resource is a gzipped tarball, let's call it {{file|resource.tar.gz}}. The resource.tar.gz contains three files: + In order to know what you should do in installResource() it is important to understand the structure of the resource you get via KNewStuffSecure. The resource is a gzipped tarball, let's call it {{path|resource.tar.gz}}. The {{path|resource.tar.gz}} contains three files:
    
  {| border="1"   {| border="1"
Line 48:
Line 48:
  |}   |}
    
− In the implementation file you have to process the {{file|data.tar.gz}} only, the rest is handled by KNewStuffSecure. If installing the resource means that you put the downloaded file(s) from data.tar.gz into a directory, the implementation of MyNewStuff looks like: + In the implementation file you have to process the {{path|data.tar.gz}} only, the rest is handled by KNewStuffSecure. If installing the resource means that you put the downloaded file(s) from {{path|data.tar.gz}} into a directory, the implementation of MyNewStuff looks like:
    
  <code cppqt3>   <code cppqt3>
Line 73:
Line 73:
    
  As you can see the name of the resource tarball you have to install is in   As you can see the name of the resource tarball you have to install is in
− "m_tarName". The above code installs the files from m_tarName to {{file|$KDEHOME/share/appname/stuff}}. Of course, you must provide the real appname there. + "m_tarName". The above code installs the files from m_tarName to {{path|$KDEHOME/share/appname/stuff}}. Of course, you must provide the real appname there.
    
  You are free to do other installation methods, depending on your needs. In some cases it may be just enough to copy the resource tarball somewhere. This part of the code depends completely on the type of the resource and your application.   You are free to do other installation methods, depending on your needs. In some cases it may be just enough to copy the resource tarball somewhere. This part of the code depends completely on the type of the resource and your application.
Line 100:
Line 100:
    
  == Uploading resources ==   == Uploading resources ==
− Uploading is simple as well. You just have to create the {{file|data.tar.gz}} (which is specific for your application) and call uploadResource(fileName), where fileName points to the created data tarball.   + Uploading is simple as well. You just have to create the {{path|data.tar.gz}} (which is specific for your application) and call uploadResource(fileName), where fileName points to the created data tarball.  
    
  Example:   Example:



Pino: wikify
2007-03-07T15:05:03Z
wikify
Show changes


Repinc: /* Resource sharing */ Fix links
2007-01-10T02:31:04Z
‎Resource sharing:  Fix links

				
				
				
				
			
			← Older revision
			Revision as of 02:31, 10 January 2007
			
Line 6:
Line 6:
  Starting with KDE 3.4 and with the introduction of the KNewStuffSecure class this problems are solved. With this technology the resources can be digitally signed, an md5sum is calculated for them, so both the uploaded and downloaded resources can be verified whether they come from a safe source and person or not.   Starting with KDE 3.4 and with the introduction of the KNewStuffSecure class this problems are solved. With this technology the resources can be digitally signed, an md5sum is calculated for them, so both the uploaded and downloaded resources can be verified whether they come from a safe source and person or not.
    
− This tutorial will explain how to use KNewStuffSecure in your application to enable downloading and uploading secured resources. It will not explain the usage of KNewStuff itself and how you can set up a resource repository on the server. These informations can be found in the KNewStuff <a href="http://developer.kde.org/documentation/library/cvs-api/knewstuff/html/">API documentation</a>, in the <a href="http://www.kstuff.org/docs/tutorial/">KNewStuff tutorial</a> and in the sources: <strong><a href="http://webcvs.kde.org/kdelibs/knewstuff/README.knewstuff?view=markup">kdelibs/knewstuff/README.knewstuff</a></strong> and <strong><a href="http://webcvs.kde.org/kdelibs/knewstuff/data">kdelibs/knewstuff/data</a></strong> .</p> + This tutorial will explain how to use KNewStuffSecure in your application to enable downloading and uploading secured resources. It will not explain the usage of KNewStuff itself and how you can set up a resource repository on the server. These informations can be found in the KNewStuff [http://developer.kde.org/documentation/library/cvs-api/knewstuff/html/ API documentation], in the [http://www.kstuff.org/docs/tutorial/ KNewStuff tutorial] and in the sources: <strong>[http://webcvs.kde.org/kdelibs/knewstuff/README.knewstuff?view=markup kdelibs/knewstuff/README.knewstuff]</strong> and <strong>[http://webcvs.kde.org/kdelibs/knewstuff/data kdelibs/knewstuff/data]</strong> .
    
  <hr />   <hr />
  + 
  <h2>General information</h2>   <h2>General information</h2>
    



CuCullin: Proofreading
2007-01-09T17:43:34Z
Proofreading

				
				
				
				
			
			← Older revision
			Revision as of 17:43, 9 January 2007
			
Line 2:
Line 2:
    
  == Resource sharing ==   == Resource sharing ==
  + Many applications work with external resources which gives them the freedom to change or extend the behavior without requiring to change the application code itself. Others are extensible with the help of binary plugins. All these external resources should be provided in a way to the user, and the most common way is to put them on the homepage of the application, which works, but it is not so convenient to the final user to get the updates. It is much easier to get them from inside the application. Luckily KDE has the corresponding technology called KNewStuff which not only makes possible to download updates and resources, but if the application supports it, it is even possible to share a resource created by the user with other users. KNewStuff has a weak point though, that you cannot really know who created a resource when downloading, nor the maintainer of the resource repository can know who created the resource that was uploaded, and there is no corruption checking either.
    
− <p>Many applications work with external resources which gives them the freedom + Starting with KDE 3.4 and with the introduction of the KNewStuffSecure class this problems are solved. With this technology the resources can be digitally signed, an md5sum is calculated for them, so both the uploaded and downloaded resources can be verified whether they come from a safe source and person or not.
−   to change or extend the behavior without requiring to change the application + 
−   code itself. Others are extensible with the help of binary plugins. All these + 
−   external resources should be provided in a way to the user, and the most + 
−   common way is to put them on the homepage of the application, which works, + 
−   but it is not so convenient to the final user to get the updates. It is more + 
−   easier to get them from inside the application. Luckily KDE has the corresponding technology called KNewStuff which not only makes possible to + 
−   download updates and resources, but if the application supports it, it is + 
−   even possible to share a resource created by the user with other users. + 
−   KNewStuff has a weak point though, that you cannot really know who created + 
−   a resource when downloading, nor the maintainer of the resource repository + 
−   can know who created the resource that was uploaded, and there is no corruption checking either.</p> + 
−   <p> + 
−   Starting with KDE 3.4 and with the introduction of the KNewStuffSecure class + 
−   this problems are solved. With this technology the resources can be digitally + 
−   signed, an md5sum is calculated for them, so both the uploaded and downloaded + 
−   resources can be verified whether they come from a safe source and person or + 
−   not.</p> + 
    
− <p>This tutorial will explain how to use KNewStuffSecure in your application to enable downloading and uploading secured resources. It will not explain the + This tutorial will explain how to use KNewStuffSecure in your application to enable downloading and uploading secured resources. It will not explain the usage of KNewStuff itself and how you can set up a resource repository on the server. These informations can be found in the KNewStuff <a href="http://developer.kde.org/documentation/library/cvs-api/knewstuff/html/">API documentation</a>, in the <a href="http://www.kstuff.org/docs/tutorial/">KNewStuff tutorial</a> and in the sources: <strong><a href="http://webcvs.kde.org/kdelibs/knewstuff/README.knewstuff?view=markup">kdelibs/knewstuff/README.knewstuff</a></strong> and <strong><a href="http://webcvs.kde.org/kdelibs/knewstuff/data">kdelibs/knewstuff/data</a></strong> .</p>
−   usage of KNewStuff itself and how you can set up a resource repository on the server. These informations can be found in the KNewStuff <a href="http://developer.kde.org/documentation/library/cvs-api/knewstuff/html/">API documentation</a>, in the <a href="http://www.kstuff.org/docs/tutorial/">KNewStuff tutorial</a> and in the sources: <strong><a href="http://webcvs.kde.org/kdelibs/knewstuff/README.knewstuff?view=markup">kdelibs/knewstuff/README.knewstuff</a></strong> and <strong><a href="http://webcvs.kde.org/kdelibs/knewstuff/data">kdelibs/knewstuff/data</a></strong> .</p> + 
    
  <hr />   <hr />



CuCullin: Created page
2007-01-09T17:22:49Z
Created page
New page
{{Improve}}



== Resource sharing ==



<p>Many applications work with external resources which gives them the freedom

  to change or extend the behavior without requiring to change the application

  code itself. Others are extensible with the help of binary plugins. All these

  external resources should be provided in a way to the user, and the most 

  common way is to put them on the homepage of the application, which works,

  but it is not so convenient to the final user to get the updates. It is more

  easier to get them from inside the application. Luckily KDE has the corresponding technology called KNewStuff which not only makes possible to

  download updates and resources, but if the application supports it, it is

  even possible to share a resource created by the user with other users.

  KNewStuff has a weak point though, that you cannot really know who created

  a resource when downloading, nor the maintainer of the resource repository

  can know who created the resource that was uploaded, and there is no corruption checking either.</p>

  <p>

  Starting with KDE 3.4 and with the introduction of the KNewStuffSecure class

  this problems are solved. With this technology the resources can be digitally

  signed, an md5sum is calculated for them, so both the uploaded and downloaded

  resources can be verified whether they come from a safe source and person or

  not.</p>



<p>This tutorial will explain how to use KNewStuffSecure in your application to enable downloading and uploading secured resources. It will not explain the

  usage of KNewStuff itself and how you can set up a resource repository on the server. These informations can be found in the KNewStuff <a href="http://developer.kde.org/documentation/library/cvs-api/knewstuff/html/">API documentation</a>, in the <a href="http://www.kstuff.org/docs/tutorial/">KNewStuff tutorial</a> and in the sources: <strong><a href="http://webcvs.kde.org/kdelibs/knewstuff/README.knewstuff?view=markup">kdelibs/knewstuff/README.knewstuff</a></strong> and <strong><a href="http://webcvs.kde.org/kdelibs/knewstuff/data">kdelibs/knewstuff/data</a></strong> .</p>



<hr />

<h2>General information</h2>



<p>Using KNewStuff itself is quite simple, and I tried to make KNewStuffSecure not

  more complicated. The only extra requirement is to have <strong>gpg</strong> installed in your

  path, and for uploading of course it is preferred if you already have a GPG key

that you can use for resource signing.</p>



<p>As <strong>gpg</strong> is not a compilation time requirement, it is suggested that you check on application startup for its presence and warn the user what he misses without it. Of course the check is performed by KNewStuffSecure as well, but I find it muchnicer to check for runtime dependencies on startup.</p>



<hr />

<h2>Downloading resources</h2>

<p>The first thing you must to is to subclass the KNewStuffSecure class and implement the installResource method, which is a pure virtual method in KNewStuffSecure. Here is an example of what you should put in a header file:</p>

<div class="codeBox">

<pre>

  #include &lt;knewstuff/knewstuffsecure.h&gt;

  class MyNewStuff: public KNewStuffSecure

  {

    Q_OBJECT

    

    public:

      MyNewStuff(const QString &type,  QWidget *parentWidget=0)

        :KNewStuffSecure(type, parentWidget){};

      ~MyNewStuff() {};

    

    private:

      virtual void installResource();

  };

</pre>

</div>

<p>In order to know what you should do in installResource() it is important to understand the structure of the resource you get via KNewStuffSecure. The resource is a gzipped tarball, let's call it resource.tar.gz. The resource.tar.gz contains three files:

</p>

<table frame="border" border="1">

  <thead>

    <tr>

      <th>Filename</th>

      <th>Description</th>

    </tr>

  </thead>

  <tbody>

    <tr>

      <td>data.tar.gz</td>

      <td>another tarball containing the actual data to be installed. The   

              name is not fixed, it can be anything like cards.tgz,

              greetings.tar.gz or whatever.</td>

    </tr>

    <tr>

      <td>signature</td>

      <td>holds the signature for data.tar.gz</td>

    </tr>

    <tr>

      <td>md5sum</td>

      <td>holds the MD5 sum for the data.tar.gz</td>

    </tr>

  </tbody>

</table>

<p>In the implementation file you have to process the data.tar.gz only, the rest is

handled by KNewStuffSecure. If installing the resource means that you put the 

downloaded file(s) from data.tar.gz into a directory, the implementation of

MyNewStuff looks like:

</p>

<div class="codeBox">

<pre>

  void MyNewStuff::installResource()

  {

    bool ok = true;

    KTar tar(m_tarName, "application/x-gzip" );

    if (tar.open(IO_ReadOnly))

    {

      const KArchiveDirectory *directory = tar.directory();

      QString resDir =KGlobal::dirs()->saveLocation("data" ) + "appname/stuff/";

      directory->copyTo(resDir, true);

      tar.close();

    } else

      ok = false;

  

    if (!ok)

      KMessageBox::error(parentWidget(), i18n("There was an error with the

      downloaded resource tarball file. Possible causes are damaged archive or

      invalid directory structure in the archive." ), 

      i18n("Resource Installation Error" ));

  }

</pre>

</div>

<p>As you can see the name of the resource tarball you have to install is in

"m_tarName". The above code installs the files from m_tarName to 

<strong>$KDEHOME/share/appname/stuff</strong>. Of course, you must provide the real appname there.

</p>

<p>You are free to do other installation methods, depending on your needs. In some

cases it may be just enough to copy the resource tarball somewhere. This part

of the code depends completely on the type of the resource and your application.

</p>

<p>Now how to initiate a download? You have to do three things:

</p>

<ul>

 <li>create a MyNewStuff object</li>

 <li>connect the signal installFinished() to a slot to do things what you want after the install is done</li>

 <li>call downloadResource() for the MyNewStuff object</li>

</ul>

<p>Example:

</p>

<div class="codeBox">

<pre>

  void MyApp::slotDownloadResource()

  {

    if (!m_newStuff)

    {

      m_newStuff = new MyNewStuff("appname/resourcetype", this);

      connect(m_newStuff, SIGNAL(installFinished()), this, SLOT(slotResourceInstalled()));

    }

    m_newStuff->downloadResource();

  }

</pre>

</div>

<p>Just a note: <em>"appname/resourcetype"</em> is in free form, it identifies the type of the resource. See the standard KNewStuff documentation for details.

</p>



<hr />

<h2>Uploading resources</h2>

<p>Uploading is simple as well. You just have to create

the data.tar.gz (which is specific for your application) and call uploadResource(fileName), where fileName points to the created data tarball. 

</p>

<p>Example:</p>

<div class="codeBox">

<pre>

  void MyApp::slotUploadResource()

  {

    QString fileName = createUploadResource();

    if (!m_newStuff)

      m_newStuff = new MyNewStuff("application/resourcetype", this);

    m_newStuff->uploadResource(fileName);

  }  

</pre>

</div>

<p>Here createUploadResource() creates the data tarball and returns the name with path to the created tarball.

</p>

<p>That is all. I hope you will find this tutorial useful.</p>

@@ Line 35: / Line 35: @@
      virtual void installResource();
 };
-</code>
+</syntaxhighlight>
 In order to know what you should do in installResource() it is important to understand the structure of the resource you get via KNewStuffSecure. The resource is a gzipped tarball, let's call it {{path|resource.tar.gz}}. The {{path|resource.tar.gz}} contains three files:
@@ Line 67: / Line 67: @@
      i18n("Resource Installation Error" ));
+}
-</code>
+</syntaxhighlight>
 As you can see the name of the resource tarball you have to install is in
@@ Line 90: / Line 90: @@
    m_newStuff->downloadResource();
+}
-</code>
+</syntaxhighlight>
 Just a note: ''"appname/resourcetype"'' is in free form, it identifies the type of the resource. See the standard KNewStuff documentation for details.
@@ Line 108: / Line 108: @@
    m_newStuff->uploadResource(fileName);
+}
-</code>
+</syntaxhighlight>
 Here createUploadResource() creates the data tarball and returns the name with path to the created tarball.
 That is all. I hope you will find this tutorial useful.

← Older revision		Revision as of 07:34, 23 November 2008
Line 1:		Line 1:
	{{Improve}}		{{Improve}}
		+	{{KDE3}}

	== Resource sharing ==		== Resource sharing ==