Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/clipboard.c

    r79ae36dd r007e6efa  
    3939
    4040#include <clipboard.h>
    41 #include <ns.h>
     41#include <ipc/ns.h>
    4242#include <ipc/services.h>
    4343#include <ipc/clipboard.h>
    44 #include <fibril_synch.h>
    4544#include <async.h>
    4645#include <str.h>
    … …  
    4847#include <malloc.h>
    4948
    50 static FIBRIL_MUTEX_INITIALIZE(clip_mutex);
    51 static async_sess_t *clip_sess = NULL;
     49static int clip_phone = -1;
    5250
    53 /** Start an async exchange on the clipboard session.
    54  *
    55  * @return New exchange.
     51/** Connect to clipboard server
    5652 *
    5753 */
    58 static async_exch_t *clip_exchange_begin(void)
     54static void clip_connect(void)
    5955{
    60         fibril_mutex_lock(&clip_mutex);
    61        
    62         while (clip_sess == NULL)
    63                 clip_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
    64                     SERVICE_CLIPBOARD, 0, 0);
    65        
    66         fibril_mutex_unlock(&clip_mutex);
    67        
    68         return async_exchange_begin(clip_sess);
    69 }
    70 
    71 /** Finish an async exchange on the clipboard session.
    72  *
    73  * @param exch Exchange to be finished.
    74  *
    75  */
    76 static void clip_exchange_end(async_exch_t *exch)
    77 {
    78         async_exchange_end(exch);
     56        while (clip_phone < 0)
     57                clip_phone = service_connect_blocking(SERVICE_CLIPBOARD, 0, 0);
    7958}
    8059
    … …  
    9473       
    9574        if (size == 0) {
    96                 async_exch_t *exch = clip_exchange_begin();
    97                 sysarg_t rc = async_req_1_0(exch, CLIPBOARD_PUT_DATA,
    98                     CLIPBOARD_TAG_NONE);
    99                 clip_exchange_end(exch);
     75                async_serialize_start();
     76                clip_connect();
     77               
     78                sysarg_t rc = async_req_1_0(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_NONE);
     79               
     80                async_serialize_end();
    10081               
    10182                return (int) rc;
    10283        } else {
    103                 async_exch_t *exch = clip_exchange_begin();
    104                 aid_t req = async_send_1(exch, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA,
    105                     NULL);
    106                 sysarg_t rc = async_data_write_start(exch, (void *) str, size);
    107                 clip_exchange_end(exch);
     84                async_serialize_start();
     85                clip_connect();
    10886               
     87                aid_t req = async_send_1(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA, NULL);
     88                sysarg_t rc = async_data_write_start(clip_phone, (void *) str, size);
    10989                if (rc != EOK) {
    11090                        sysarg_t rc_orig;
    11191                        async_wait_for(req, &rc_orig);
     92                        async_serialize_end();
    11293                        if (rc_orig == EOK)
    11394                                return (int) rc;
    … …  
    11798               
    11899                async_wait_for(req, &rc);
     100                async_serialize_end();
    119101               
    120102                return (int) rc;
    … …  
    135117        /* Loop until clipboard read succesful */
    136118        while (true) {
    137                 async_exch_t *exch = clip_exchange_begin();
     119                async_serialize_start();
     120                clip_connect();
    138121               
    139122                sysarg_t size;
    140123                sysarg_t tag;
    141                 sysarg_t rc = async_req_0_2(exch, CLIPBOARD_CONTENT, &size, &tag);
     124                sysarg_t rc = async_req_0_2(clip_phone, CLIPBOARD_CONTENT, &size, &tag);
    142125               
    143                 clip_exchange_end(exch);
     126                async_serialize_end();
    144127               
    145128                if (rc != EOK)
    … …  
    162145                                return ENOMEM;
    163146                       
    164                         exch = clip_exchange_begin();
    165                         aid_t req = async_send_1(exch, CLIPBOARD_GET_DATA, tag, NULL);
    166                         rc = async_data_read_start(exch, (void *) sbuf, size);
    167                         clip_exchange_end(exch);
     147                        async_serialize_start();
    168148                       
     149                        aid_t req = async_send_1(clip_phone, CLIPBOARD_GET_DATA, tag, NULL);
     150                        rc = async_data_read_start(clip_phone, (void *) sbuf, size);
    169151                        if ((int) rc == EOVERFLOW) {
    170152                                /*
    … …  
    172154                                 * the last call of CLIPBOARD_CONTENT
    173155                                 */
     156                                async_serialize_end();
    174157                                break;
    175158                        }
    … …  
    178161                                sysarg_t rc_orig;
    179162                                async_wait_for(req, &rc_orig);
     163                                async_serialize_end();
    180164                                if (rc_orig == EOK)
    181165                                        return (int) rc;
    … …  
    185169                       
    186170                        async_wait_for(req, &rc);
     171                        async_serialize_end();
    187172                       
    188173                        if (rc == EOK) {
Note: See TracChangeset for help on using the changeset viewer.